move StaticType to devirtualize pkg

Change-Id: Iadcbf84a666a3e43ce2b460e064b111efa0f2022

src/cmd/compile/internal/devirtualize/devirtualize.go

@@ -40,11 +40,16 @@ func StaticCall(call *ir.CallExpr) {
 	}
 
 	sel := call.Fun.(*ir.SelectorExpr)
-	typ := ir.StaticType(sel.X)
+	typ := staticType(sel.X)
 	if typ == nil {
 		return
 	}
 
+	// Don't try to devirtualize calls that we statically know that would have failed at runtime.
+	// This can happen in such case: any(0).(interface {A()}).A(), this typechecks without
+	// any errors, but will cause a runtime panic. We statically know that int(0) does not
+	// implement that interface, thus we skip the devirtualization, as it is not possible
+	// to make a type assertion from interface{A()} to int (int does not implement interface{A()}).
 	if !typecheck.Implements(typ, sel.X.Type()) {
 		return
 	}
@@ -136,3 +141,85 @@ func StaticCall(call *ir.CallExpr) {
 	// Desugar OCALLMETH, if we created one (#57309).
 	typecheck.FixMethodCall(call)
 }
+
+func staticType(n ir.Node) *types.Type {
+	for {
+		switch n1 := n.(type) {
+		case *ir.ConvExpr:
+			if n1.Op() == ir.OCONVNOP || n1.Op() == ir.OCONVIFACE {
+				n = n1.X
+				continue
+			}
+		case *ir.InlinedCallExpr:
+			if n1.Op() == ir.OINLCALL {
+				n = n1.SingleResult()
+				continue
+			}
+		case *ir.ParenExpr:
+			n = n1.X
+			continue
+		case *ir.TypeAssertExpr:
+			n = n1.X
+			continue
+		}
+
+		n1 := staticValue(n)
+		if n1 == nil {
+			if n.Type().IsInterface() {
+				return nil
+			}
+			return n.Type()
+		}
+		n = n1
+	}
+}
+
+func staticValue(nn ir.Node) ir.Node {
+	if nn.Op() != ir.ONAME {
+		return nil
+	}
+
+	n := nn.(*ir.Name).Canonical()
+	if n.Class != ir.PAUTO {
+		return nil
+	}
+
+	defn := n.Defn
+	if defn == nil {
+		return nil
+	}
+
+	var rhs ir.Node
+FindRHS:
+	switch defn.Op() {
+	case ir.OAS:
+		defn := defn.(*ir.AssignStmt)
+		rhs = defn.Y
+	case ir.OAS2:
+		defn := defn.(*ir.AssignListStmt)
+		for i, lhs := range defn.Lhs {
+			if lhs == n {
+				rhs = defn.Rhs[i]
+				break FindRHS
+			}
+		}
+		base.Fatalf("%v missing from LHS of %v", n, defn)
+	case ir.OAS2DOTTYPE:
+		defn := defn.(*ir.AssignListStmt)
+		if defn.Lhs[0] == n {
+			rhs = defn.Rhs[0]
+		}
+	default:
+		return nil
+	}
+
+	if rhs == nil {
+		base.Fatalf("RHS is nil: %v", defn)
+	}
+
+	if ir.Reassigned(n) {
+		return nil
+	}
+
+	return rhs
+}

src/cmd/compile/internal/ir/expr.go

@@ -840,18 +840,6 @@ func IsAddressable(n Node) bool {
 	return false
 }
 
-// StaticType is like StaticValue, but also follows ODOTTYPE and OCONVIFACE.
-func StaticType(n Node) *types.Type {
-	out := staticValue(n, true)
-
-	typ := out.Type()
-	if typ.IsInterface() {
-		return nil
-	}
-
-	return typ
-}
-
 // StaticValue analyzes n to find the earliest expression that always
 // evaluates to the same value as n, which might be from an enclosing
 // function.
@@ -867,22 +855,13 @@ func StaticType(n Node) *types.Type {
 // calling StaticValue on the "int(y)" expression returns the outer
 // "g()" expression.
 func StaticValue(n Node) Node {
-	return staticValue(n, false)
-
-}
-
-func staticValue(n Node, forDevirt bool) Node {
 	for {
 		switch n1 := n.(type) {
 		case *ConvExpr:
 			if n1.Op() == OCONVNOP {
 				n = n1.X
 				continue
 			}
-			if forDevirt && n1.Op() == OCONVIFACE {
-				n = n1.X
-				continue
-			}
 		case *InlinedCallExpr:
 			if n1.Op() == OINLCALL {
 				n = n1.SingleResult()
@@ -891,22 +870,17 @@ func staticValue(n Node, forDevirt bool) Node {
 		case *ParenExpr:
 			n = n1.X
 			continue
-		case *TypeAssertExpr:
-			if forDevirt {
-				n = n1.X
-				continue
-			}
 		}
 
-		n1 := staticValue1(n, forDevirt)
+		n1 := staticValue1(n)
 		if n1 == nil {
 			return n
 		}
 		n = n1
 	}
 }
 
-func staticValue1(nn Node, forDevirt bool) Node {
+func staticValue1(nn Node) Node {
 	if nn.Op() != ONAME {
 		return nil
 	}
@@ -935,14 +909,6 @@ FindRHS:
 			}
 		}
 		base.Fatalf("%v missing from LHS of %v", n, defn)
-	case OAS2DOTTYPE:
-		if !forDevirt {
-			return nil
-		}
-		defn := defn.(*AssignListStmt)
-		if defn.Lhs[0] == n {
-			rhs = defn.Rhs[0]
-		}
 	default:
 		return nil
 	}

test/escape_iface_with_devirt_type_assertions.go

@@ -143,8 +143,55 @@ func callIfA(m M) { // ERROR "can inline" "leaking param"
 	}
 }
 
+//go:noinline
+func newImplNoInline() *Impl {
+	return &Impl{} // ERROR "escapes"
+}
+
+func t3() {
+	{
+		var a A = newImplNoInline()
+		if v, ok := a.(M); ok {
+			v.M() // ERROR "devirtualizing" "inlining call"
+		}
+	}
+	{
+		m := make(map[*Impl]struct{}) // ERROR "does not escape"
+		for v := range m {
+			var v A = v
+			if v, ok := v.(M); ok {
+				v.M() // ERROR "devirtualizing" "inlining call"
+			}
+		}
+	}
+	{
+		m := make(map[int]*Impl) // ERROR "does not escape"
+		for _, v := range m {
+			var v A = v
+			if v, ok := v.(M); ok {
+				v.M() // ERROR "devirtualizing" "inlining call"
+			}
+		}
+	}
+	{
+		m := make(map[int]*Impl) // ERROR "does not escape"
+		var v A = m[0]
+		if v, ok := v.(M); ok {
+			v.M() // ERROR "devirtualizing" "inlining call"
+		}
+	}
+	{
+		m := make(chan *Impl)
+		var v A = <-m
+		if v, ok := v.(M); ok {
+			v.M() // ERROR "devirtualizing" "inlining call"
+		}
+	}
+}
+
 //go:noinline
 func testInvalidAsserts() {
+	any(0).(interface{ A() }).A() // ERROR "escapes"
 	{
 		var a M = &Impl{} // ERROR "escapes"
 		a.(C).C()         // this will panic