[dev.unified] cmd/compile/internal/noder: implicit conversions for binary exprs

Binary operations (except for shifts) require one operand to be
assignable to the other's type. In particular, for equality
comparisons, this can imply a conversion to interface type.

Change-Id: Ic973c8287a40fdaefcf11458378574fdcd243b17
Reviewed-on: https://go-review.googlesource.com/c/go/+/415577
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>

diff --git a/src/cmd/compile/internal/noder/writer.go b/src/cmd/compile/internal/noder/writer.go
index 7830b94cd89335091dedb9d6403c72d582f3152d..6036695de130e982c8654ab3e6b10b2cc51ef46c 100644 (file)
--- a/src/cmd/compile/internal/noder/writer.go
+++ b/src/cmd/compile/internal/noder/writer.go
@@ -1499,12 +1499,28 @@ func (w *writer) expr(expr syntax.Expr) {
                        break
                }
 
-               // TODO(mdempsky): Implicit conversions to common type.
+               var commonType types2.Type
+               switch expr.Op {
+               case syntax.Shl, syntax.Shr:
+                       // ok: operands are allowed to have different types
+               default:
+                       xtyp := w.p.typeOf(expr.X)
+                       ytyp := w.p.typeOf(expr.Y)
+                       switch {
+                       case types2.AssignableTo(xtyp, ytyp):
+                               commonType = ytyp
+                       case types2.AssignableTo(ytyp, xtyp):
+                               commonType = xtyp
+                       default:
+                               w.p.fatalf(expr, "failed to find common type between %v and %v", xtyp, ytyp)
+                       }
+               }
+
                w.Code(exprBinaryOp)
                w.op(binOps[expr.Op])
-               w.expr(expr.X)
+               w.implicitConvExpr(expr, commonType, expr.X)
                w.pos(expr)
-               w.expr(expr.Y)
+               w.implicitConvExpr(expr, commonType, expr.Y)
 
        case *syntax.CallExpr:
                tv, ok := w.p.info.Types[expr.Fun]