devirtualize v, ok := v.(T)

Change-Id: I6249fd63bc4734640055a2f764eb4e73a4e2adbb

Author: mateusz834

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

@@ -892,21 +892,22 @@ func staticValue(n Node, forDevirt bool) Node {
 			n = n1.X
 			continue
 		case *TypeAssertExpr:
-			if forDevirt && n1.Op() == ODOTTYPE {
+			if forDevirt {
 				n = n1.X
 				continue
 			}
 		}
 
-		n1 := staticValue1(n)
+		n1 := staticValue1(n, forDevirt)
 		if n1 == nil {
 			return n
 		}
+
 		n = n1
 	}
 }
 
-func staticValue1(nn Node) Node {
+func staticValue1(nn Node, forDevirt bool) Node {
 	if nn.Op() != ONAME {
 		return nil
 	}
@@ -935,6 +936,14 @@ 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
 	}
@@ -945,7 +954,6 @@ FindRHS:
 	if Reassigned(n) {
 		return nil
 	}
-
 	return rhs
 }
 

src/cmd/compile/internal/noder/reader.go

@@ -2937,10 +2937,12 @@ func (r *reader) multiExpr() []ir.Node {
 		expr := r.expr()
 
 		results := make([]ir.Node, r.Len())
+
 		as := ir.NewAssignListStmt(pos, ir.OAS2, nil, []ir.Node{expr})
 		as.Def = true
 		for i := range results {
 			tmp := r.temp(pos, r.typ())
+			tmp.Defn = as
 			as.PtrInit().Append(ir.NewDecl(pos, ir.ODCL, tmp))
 			as.Lhs.Append(tmp)
 

src/cmd/compile/internal/typecheck/dcl.go

@@ -92,6 +92,7 @@ func autotmpname(n int) string {
 		s = fmt.Sprintf(prefix, n)
 		autotmpnames[n] = s
 	}
+
 	return s
 }
 

test/escape_iface_with_devirt_type_assertions.go

@@ -63,32 +63,31 @@ func t() {
 	}
 }
 
-// TODO: these type assertions could also be devirtualized.
 func t2() {
 	{
-		var a M = &Impl{} // ERROR "&Impl{} escapes to heap"
+		var a M = &Impl{} // ERROR "does not escape"
 		if v, ok := a.(M); ok {
-			v.M()
+			v.M() // ERROR "devirtualizing" "inlining call"
 		}
 	}
 	{
-		var a M = &Impl{} // ERROR "&Impl{} escapes to heap"
+		var a M = &Impl{} // ERROR "does not escape"
 		if v, ok := a.(A); ok {
-			v.A()
+			v.A() // ERROR "devirtualizing" "inlining call"
 		}
 	}
 	{
-		var a M = &Impl{} // ERROR "&Impl{} escapes to heap"
+		var a M = &Impl{} // ERROR "does not escape"
 		v, ok := a.(M)
 		if ok {
-			v.M()
+			v.M() // ERROR "devirtualizing" "inlining call"
 		}
 	}
 	{
-		var a M = &Impl{} // ERROR "&Impl{} escapes to heap"
+		var a M = &Impl{} // ERROR "does not escape"
 		v, ok := a.(A)
 		if ok {
-			v.A()
+			v.A() // ERROR "devirtualizing" "inlining call"
 		}
 	}
 	{
@@ -100,21 +99,40 @@ func t2() {
 		}
 	}
 	{
-		var a M = &Impl{} // ERROR "&Impl{} escapes to heap"
+		var a M = &Impl{} // ERROR "does not escape"
 		v, _ := a.(M)
-		v.M()
+		v.M() // ERROR "devirtualizing" "inlining call"
 	}
 	{
-		var a M = &Impl{} // ERROR "&Impl{} escapes to heap"
+		var a M = &Impl{} // ERROR "does not escape"
 		v, _ := a.(A)
-		v.A()
+		v.A() // ERROR "devirtualizing" "inlining call"
 	}
 	{
 		var a M = &Impl{} // ERROR "does not escape"
 		v, _ := a.(*Impl)
 		v.A() // ERROR "inlining"
 		v.M() // ERROR "inlining"
 	}
+	{
+		a := newM() // ERROR "does not escape" "inlining call"
+		callA(a)    // ERROR "devirtualizing" "inlining call"
+		callIfA(a)  // ERROR "devirtualizing" "inlining call"
+	}
+}
+
+func newM() M { // ERROR "can inline"
+	return &Impl{} // ERROR "escapes"
+}
+
+func callA(m M) { // ERROR "can inline" "leaking param"
+	m.(A).A()
+}
+
+func callIfA(m M) { // ERROR "can inline" "leaking param"
+	if v, ok := m.(A); ok {
+		v.A()
+	}
 }
 
 //go:noinline