cmd/compile: replace calls to typecheck with transform functions

For additions, compares, and slices, create transform functions that do
just the transformations for those nodes by the typecheck package (given
that the code has been fully typechecked by types2). For nodes that have
no args with typeparams, we call these transform functions directly in
noder2. But for nodes that have args with typeparams, we have to delay
and call the tranform functions during stenciling, since we don't know
the specific types involved.

We indicate that a node still needs transformation by setting Typecheck
to a new value 3. This value means the current type of the node has been
set (via types2), but the node may still need transformation.

Had to export typcheck.IsCmp and typecheck.Assignop from the typecheck
package.

Added new tests list2.go (required delaying compare typecheck/transform
because of != compare in checkList) and adder.go (requires delaying add
typecheck/transform, since it can do addition for numbers or strings).

There are several more transformation functions needed for expressions
(indexing, calls, etc.) and several more complicated ones needed for
statements (mainly various kinds of assignments).

Change-Id: I7d89d13a4108308ea0304a4b815ab60b40c59b0a
Reviewed-on: https://go-review.googlesource.com/c/go/+/303091
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Dan Scales <danscales@google.com>
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>

8 files changed, 155 insertions, 24 deletions

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 38f9123582..7bce0e985c 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -48,6 +48,12 @@ type Node interface {
 	SetEsc(x uint16)
 	Diag() bool
 	SetDiag(x bool)
+
+	// Typecheck values:
+	//  0 means the node is not typechecked
+	//  1 means the node is completely typechecked
+	//  2 means typechecking of the node is in progress
+	//  3 means the node has its type from types2, but may need transformation
 	Typecheck() uint8
 	SetTypecheck(x uint8)
 	NonNil() bool
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 957295bdf0..effc63c09a 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -64,7 +64,7 @@ func (g *irgen) expr(expr syntax.Expr) ir.Node {
 	}
 
 	n := g.expr0(typ, expr)
-	if n.Typecheck() != 1 {
+	if n.Typecheck() != 1 && n.Typecheck() != 3 {
 		base.FatalfAt(g.pos(expr), "missed typecheck: %+v", n)
 	}
 	if !g.match(n.Type(), typ, tv.HasOk()) {
@@ -161,7 +161,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 		return g.selectorExpr(pos, typ, expr)
 
 	case *syntax.SliceExpr:
-		return Slice(pos, g.expr(expr.X), g.expr(expr.Index[0]), g.expr(expr.Index[1]), g.expr(expr.Index[2]))
+		return Slice(pos, g.typ(typ), g.expr(expr.X), g.expr(expr.Index[0]), g.expr(expr.Index[1]), g.expr(expr.Index[2]))
 
 	case *syntax.Operation:
 		if expr.Y == nil {
@@ -171,7 +171,7 @@ func (g *irgen) expr0(typ types2.Type, expr syntax.Expr) ir.Node {
 		case ir.OEQ, ir.ONE, ir.OLT, ir.OLE, ir.OGT, ir.OGE:
 			return Compare(pos, g.typ(typ), op, g.expr(expr.X), g.expr(expr.Y))
 		default:
-			return Binary(pos, op, g.expr(expr.X), g.expr(expr.Y))
+			return Binary(pos, op, g.typ(typ), g.expr(expr.X), g.expr(expr.Y))
 		}
 
 	default:
diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index 1210d4b58c..e4a1a54fe8 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -67,16 +67,47 @@ func Assert(pos src.XPos, x ir.Node, typ *types.Type) ir.Node {
 	return typed(typ, ir.NewTypeAssertExpr(pos, x, nil))
 }
 
-func Binary(pos src.XPos, op ir.Op, x, y ir.Node) ir.Node {
+// transformAdd transforms an addition operation (currently just addition of
+// strings). Equivalent to the "binary operators" case in typecheck.typecheck1.
+func transformAdd(n *ir.BinaryExpr) ir.Node {
+	l := n.X
+	if l.Type().IsString() {
+		var add *ir.AddStringExpr
+		if l.Op() == ir.OADDSTR {
+			add = l.(*ir.AddStringExpr)
+			add.SetPos(n.Pos())
+		} else {
+			add = ir.NewAddStringExpr(n.Pos(), []ir.Node{l})
+		}
+		r := n.Y
+		if r.Op() == ir.OADDSTR {
+			r := r.(*ir.AddStringExpr)
+			add.List.Append(r.List.Take()...)
+		} else {
+			add.List.Append(r)
+		}
+		add.SetType(l.Type())
+		return add
+	}
+	return n
+}
+
+func Binary(pos src.XPos, op ir.Op, typ *types.Type, x, y ir.Node) ir.Node {
 	switch op {
 	case ir.OANDAND, ir.OOROR:
 		return typed(x.Type(), ir.NewLogicalExpr(pos, op, x, y))
 	case ir.OADD:
-		if x.Type().IsString() {
-			// TODO(mdempsky): Construct OADDSTR directly.
-			return typecheck.Expr(ir.NewBinaryExpr(pos, op, x, y))
+		n := ir.NewBinaryExpr(pos, op, x, y)
+		if x.Type().HasTParam() || y.Type().HasTParam() {
+			// Delay transformAdd() if either arg has a type param,
+			// since it needs to know the exact types to decide whether
+			// to transform OADD to OADDSTR.
+			n.SetType(typ)
+			n.SetTypecheck(3)
+			return n
 		}
-		fallthrough
+		n1 := transformAdd(n)
+		return typed(typ, n1)
 	default:
 		return typed(x.Type(), ir.NewBinaryExpr(pos, op, x, y))
 	}
@@ -178,12 +209,56 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool)
 	return n
 }
 
+// transformCompare transforms a compare operation (currently just equals/not
+// equals). Equivalent to the "comparison operators" case in
+// typecheck.typecheck1, including tcArith.
+func transformCompare(n *ir.BinaryExpr) {
+	if (n.Op() == ir.OEQ || n.Op() == ir.ONE) && !types.Identical(n.X.Type(), n.Y.Type()) {
+		// Comparison is okay as long as one side is assignable to the
+		// other. The only allowed case where the conversion is not CONVNOP is
+		// "concrete == interface". In that case, check comparability of
+		// the concrete type. The conversion allocates, so only do it if
+		// the concrete type is huge.
+		l, r := n.X, n.Y
+		lt, rt := l.Type(), r.Type()
+		converted := false
+		if rt.Kind() != types.TBLANK {
+			aop, _ := typecheck.Assignop(lt, rt)
+			if aop != ir.OXXX {
+				types.CalcSize(lt)
+				if rt.IsInterface() == lt.IsInterface() || lt.Width >= 1<<16 {
+					l = ir.NewConvExpr(base.Pos, aop, rt, l)
+					l.SetTypecheck(1)
+				}
+
+				converted = true
+			}
+		}
+
+		if !converted && lt.Kind() != types.TBLANK {
+			aop, _ := typecheck.Assignop(rt, lt)
+			if aop != ir.OXXX {
+				types.CalcSize(rt)
+				if rt.IsInterface() == lt.IsInterface() || rt.Width >= 1<<16 {
+					r = ir.NewConvExpr(base.Pos, aop, lt, r)
+					r.SetTypecheck(1)
+				}
+			}
+		}
+		n.X, n.Y = l, r
+	}
+}
+
 func Compare(pos src.XPos, typ *types.Type, op ir.Op, x, y ir.Node) ir.Node {
 	n := ir.NewBinaryExpr(pos, op, x, y)
-	if !types.Identical(x.Type(), y.Type()) {
-		// TODO(mdempsky): Handle subtleties of constructing mixed-typed comparisons.
-		n = typecheck.Expr(n).(*ir.BinaryExpr)
+	if x.Type().HasTParam() || y.Type().HasTParam() {
+		// Delay transformCompare() if either arg has a type param, since
+		// it needs to know the exact types to decide on any needed conversions.
+		n.SetType(typ)
+		n.SetTypecheck(3)
+		return n
 	}
+	transformCompare(n)
 	return typed(typ, n)
 }
 
@@ -267,13 +342,42 @@ func Index(pos src.XPos, typ *types.Type, x, index ir.Node) ir.Node {
 	return typecheck.Expr(n)
 }
 
-func Slice(pos src.XPos, x, low, high, max ir.Node) ir.Node {
+// transformSlice transforms a slice operation.  Equivalent to typecheck.tcSlice.
+func transformSlice(n *ir.SliceExpr) {
+	l := n.X
+	if l.Type().IsArray() {
+		addr := typecheck.NodAddr(n.X)
+		addr.SetImplicit(true)
+		typed(types.NewPtr(n.X.Type()), addr)
+		n.X = addr
+		l = addr
+	}
+	t := l.Type()
+	if t.IsString() {
+		n.SetOp(ir.OSLICESTR)
+	} else if t.IsPtr() && t.Elem().IsArray() {
+		if n.Op().IsSlice3() {
+			n.SetOp(ir.OSLICE3ARR)
+		} else {
+			n.SetOp(ir.OSLICEARR)
+		}
+	}
+}
+
+func Slice(pos src.XPos, typ *types.Type, x, low, high, max ir.Node) ir.Node {
 	op := ir.OSLICE
 	if max != nil {
 		op = ir.OSLICE3
 	}
-	// TODO(mdempsky): Avoid typecheck.Expr.
-	return typecheck.Expr(ir.NewSliceExpr(pos, op, x, low, high, max))
+	n := ir.NewSliceExpr(pos, op, x, low, high, max)
+	if x.Type().HasTParam() {
+		// transformSlice needs to know if x.Type() is a string or an array or a slice.
+		n.SetType(typ)
+		n.SetTypecheck(3)
+		return n
+	}
+	transformSlice(n)
+	return typed(typ, n)
 }
 
 func Unary(pos src.XPos, op ir.Op, x ir.Node) ir.Node {
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 51ef46c7e7..1b76bb27c5 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -367,6 +367,23 @@ func (subst *subster) node(n ir.Node) ir.Node {
 		}
 		ir.EditChildren(m, edit)
 
+		if x.Typecheck() == 3 {
+			// These are nodes whose transforms were delayed until
+			// their instantiated type was known.
+			if typecheck.IsCmp(x.Op()) {
+				transformCompare(m.(*ir.BinaryExpr))
+				m.SetTypecheck(1)
+			} else if x.Op() == ir.OSLICE || x.Op() == ir.OSLICE3 {
+				transformSlice(m.(*ir.SliceExpr))
+				m.SetTypecheck(1)
+			} else if x.Op() == ir.OADD {
+				m = transformAdd(m.(*ir.BinaryExpr))
+				m.SetTypecheck(1)
+			} else {
+				base.Fatalf("Unexpected node with Typecheck() == 3")
+			}
+		}
+
 		switch x.Op() {
 		case ir.OLITERAL:
 			t := m.Type()
diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go
index 10a4c1b1dc..fb39709686 100644
--- a/src/cmd/compile/internal/typecheck/expr.go
+++ b/src/cmd/compile/internal/typecheck/expr.go
@@ -77,6 +77,10 @@ func tcShift(n, l, r ir.Node) (ir.Node, ir.Node, *types.Type) {
 	return l, r, t
 }
 
+func IsCmp(op ir.Op) bool {
+	return iscmp[op]
+}
+
 // tcArith typechecks operands of a binary arithmetic expression.
 // The result of tcArith MUST be assigned back to original operands,
 // t is the type of the expression, and should be set by the caller. e.g:
@@ -102,7 +106,7 @@ func tcArith(n ir.Node, op ir.Op, l, r ir.Node) (ir.Node, ir.Node, *types.Type)
 		// The conversion allocates, so only do it if the concrete type is huge.
 		converted := false
 		if r.Type().Kind() != types.TBLANK {
-			aop, _ = assignop(l.Type(), r.Type())
+			aop, _ = Assignop(l.Type(), r.Type())
 			if aop != ir.OXXX {
 				if r.Type().IsInterface() && !l.Type().IsInterface() && !types.IsComparable(l.Type()) {
 					base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(l.Type()))
@@ -121,7 +125,7 @@ func tcArith(n ir.Node, op ir.Op, l, r ir.Node) (ir.Node, ir.Node, *types.Type)
 		}
 
 		if !converted && l.Type().Kind() != types.TBLANK {
-			aop, _ = assignop(r.Type(), l.Type())
+			aop, _ = Assignop(r.Type(), l.Type())
 			if aop != ir.OXXX {
 				if l.Type().IsInterface() && !r.Type().IsInterface() && !types.IsComparable(r.Type()) {
 					base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, op, typekind(r.Type()))
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index 14ed175be9..175216f279 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -74,7 +74,7 @@ func typecheckrangeExpr(n *ir.RangeStmt) {
 			if ir.DeclaredBy(nn, n) {
 				nn.SetType(t)
 			} else if nn.Type() != nil {
-				if op, why := assignop(t, nn.Type()); op == ir.OXXX {
+				if op, why := Assignop(t, nn.Type()); op == ir.OXXX {
 					base.ErrorfAt(n.Pos(), "cannot assign type %v to %L in range%s", t, nn, why)
 				}
 			}
@@ -519,8 +519,8 @@ func tcSwitchExpr(n *ir.SwitchStmt) {
 			} else if t.IsInterface() && !n1.Type().IsInterface() && !types.IsComparable(n1.Type()) {
 				base.ErrorfAt(ncase.Pos(), "invalid case %L in switch (incomparable type)", n1)
 			} else {
-				op1, _ := assignop(n1.Type(), t)
-				op2, _ := assignop(t, n1.Type())
+				op1, _ := Assignop(n1.Type(), t)
+				op2, _ := Assignop(t, n1.Type())
 				if op1 == ir.OXXX && op2 == ir.OXXX {
 					if n.Tag != nil {
 						base.ErrorfAt(ncase.Pos(), "invalid case %v in switch on %v (mismatched types %v and %v)", n1, n.Tag, n1.Type(), t)
diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index c40cfa2288..e58ef9fb05 100644
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -317,7 +317,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 		return n
 	}
 
-	op, why := assignop(n.Type(), t)
+	op, why := Assignop(n.Type(), t)
 	if op == ir.OXXX {
 		base.Errorf("cannot use %L as type %v in %s%s", n, t, context(), why)
 		op = ir.OCONV
@@ -333,7 +333,7 @@ func assignconvfn(n ir.Node, t *types.Type, context func() string) ir.Node {
 // If so, return op code to use in conversion.
 // If not, return OXXX. In this case, the string return parameter may
 // hold a reason why. In all other cases, it'll be the empty string.
-func assignop(src, dst *types.Type) (ir.Op, string) {
+func Assignop(src, dst *types.Type) (ir.Op, string) {
 	if src == dst {
 		return ir.OCONVNOP, ""
 	}
@@ -483,7 +483,7 @@ func convertop(srcConstant bool, src, dst *types.Type) (ir.Op, string) {
 	}
 
 	// 1. src can be assigned to dst.
-	op, why := assignop(src, dst)
+	op, why := Assignop(src, dst)
 	if op != ir.OXXX {
 		return op, why
 	}
diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index 30632ac18b..f06a8623d0 100644
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -297,7 +297,7 @@ func typecheck(n ir.Node, top int) (res ir.Node) {
 
 	// Skip typecheck if already done.
 	// But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
-	if n.Typecheck() == 1 {
+	if n.Typecheck() == 1 || n.Typecheck() == 3 {
 		switch n.Op() {
 		case ir.ONAME, ir.OTYPE, ir.OLITERAL, ir.OPACK:
 			break
@@ -1640,7 +1640,7 @@ func checkassignto(src *types.Type, dst ir.Node) {
 		return
 	}
 
-	if op, why := assignop(src, dst.Type()); op == ir.OXXX {
+	if op, why := Assignop(src, dst.Type()); op == ir.OXXX {
 		base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
 		return
 	}