[dev.unified] cmd/compile/internal/noder: implicit conversion of call arguments

Function call arguments need to be implicitly converted to their
respective parameter types. This CL updates the Unified IR writer to
handle this case, at least for typical function calls. I'll handle
f(g()) calls is a subsequent CL.

Change-Id: I7c031d21f57885c9516eaf89eca517977bf9e39a
Reviewed-on: https://go-review.googlesource.com/c/go/+/413514
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>

diff --git a/src/cmd/compile/internal/noder/writer.go b/src/cmd/compile/internal/noder/writer.go
index e773b8973dc68f9e9824268a5700613ae8ccc285..5160cfaac68d5984d9f08052be5e9a9838b94289 100644 (file)
--- a/src/cmd/compile/internal/noder/writer.go
+++ b/src/cmd/compile/internal/noder/writer.go
@@ -1519,6 +1519,9 @@ func (w *writer) expr(expr syntax.Expr) {
                        w.Bool(false) // not a method call (i.e., normal function call)
                }
 
+               sigType := types2.CoreType(tv.Type).(*types2.Signature)
+               paramTypes := sigType.Params()
+
                w.Code(exprCall)
                writeFunExpr()
                w.pos(expr)
@@ -1527,7 +1530,20 @@ func (w *writer) expr(expr syntax.Expr) {
                        assert(!expr.HasDots)
                        w.expr(expr.ArgList[0]) // TODO(mdempsky): Implicit conversions to parameter types.
                } else {
-                       w.exprs(expr.ArgList) // TODO(mdempsky): Implicit conversions to parameter types.
+                       // Like w.exprs(expr.ArgList), but with implicit conversions to parameter types.
+                       args := expr.ArgList
+                       w.Sync(pkgbits.SyncExprs)
+                       w.Len(len(args))
+                       for i, arg := range args {
+                               var paramType types2.Type
+                               if sigType.Variadic() && !expr.HasDots && i+1 >= paramTypes.Len() {
+                                       paramType = paramTypes.At(paramTypes.Len() - 1).Type().(*types2.Slice).Elem()
+                               } else {
+                                       paramType = paramTypes.At(i).Type()
+                               }
+                               w.implicitExpr(expr, paramType, arg)
+                       }
+
                        w.Bool(expr.HasDots)
                }
        }