go/ssa: lift structs, arrays and typeparams

Lift locals with underlying types of struct, array and typeparam.

Changes to vta tests are due to the tests being sensitive to register names.

Change-Id: I558c0e6897b62f93ae1e700307e6e1e4dea008d0
Reviewed-on: https://go-review.googlesource.com/c/tools/+/451996
Run-TryBot: Tim King <[email protected]>
Commit-Queue: Tim King <[email protected]>
gopls-CI: kokoro <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>
Reviewed-by: Zvonimir Pavlinovic <[email protected]>

Author: timothy-king

go/callgraph/vta/graph_test.go

@@ -152,21 +152,21 @@ func vtaGraphStr(g vtaGraph) []string {
 	return vgs
 }
 
-// subGraph checks if a graph `g1` is a subgraph of graph `g2`.
-// Assumes that each element in `g1` and `g2` is an edge set
-// for a particular node in a fixed yet arbitrary format.
-func subGraph(g1, g2 []string) bool {
-	m := make(map[string]bool)
-	for _, s := range g2 {
-		m[s] = true
+// setdiff returns the set difference of `X-Y` or {s | s ∈ X, s ∉ Y }.
+func setdiff(X, Y []string) []string {
+	y := make(map[string]bool)
+	var delta []string
+	for _, s := range Y {
+		y[s] = true
 	}
 
-	for _, s := range g1 {
-		if _, ok := m[s]; !ok {
-			return false
+	for _, s := range X {
+		if _, ok := y[s]; !ok {
+			delta = append(delta, s)
 		}
 	}
-	return true
+	sort.Strings(delta)
+	return delta
 }
 
 func TestVTAGraphConstruction(t *testing.T) {
@@ -201,8 +201,9 @@ func TestVTAGraphConstruction(t *testing.T) {
 			}
 
 			g, _ := typePropGraph(ssautil.AllFunctions(prog), cha.CallGraph(prog))
-			if gs := vtaGraphStr(g); !subGraph(want, gs) {
-				t.Errorf("`%s`: want superset of %v;\n got %v", file, want, gs)
+			got := vtaGraphStr(g)
+			if diff := setdiff(want, got); len(diff) > 0 {
+				t.Errorf("`%s`: want superset of %v;\n got %v\ndiff: %v", file, want, got, diff)
 			}
 		})
 	}

go/callgraph/vta/testdata/src/callgraph_collections.go

@@ -37,31 +37,5 @@ func Baz(a A, b B) {
 	x[len(x)-1].Foo()
 }
 
-// Relevant SSA:
-// func Baz(a A, b B):
-//   ...
-//   t4 = Do(t2, t3)
-//   t5 = range t4
-//   jump 1
-//  1:
-//   t6 = phi [0: nil:[]I, 2: t16] #x
-//   t7 = next t5
-//   t8 = extract t7 #0
-//   if t8 goto 2 else 3
-//  2:
-//   t9 = extract t7 #1
-//   t10 = extract t7 #2
-//   t11 = invoke t9.Foo()
-//   t12 = invoke t10.Foo()
-//   ...
-//   jump 1
-//  3:
-//   t17 = len(t6)
-//   t18 = t17 - 1:int
-//   t19 = &t6[t18]
-//   t20 = *t19
-//   t21 = invoke t20.Foo()
-//   return
-
 // WANT:
-// Baz: Do(t2, t3) -> Do; invoke t10.Foo() -> B.Foo; invoke t20.Foo() -> A.Foo, B.Foo; invoke t9.Foo() -> A.Foo, B.Foo
+// Baz: Do(a, b) -> Do; invoke t16.Foo() -> A.Foo, B.Foo; invoke t5.Foo() -> A.Foo, B.Foo; invoke t6.Foo() -> B.Foo

go/callgraph/vta/testdata/src/callgraph_fields.go

@@ -31,61 +31,6 @@ func Baz(b B) {
 	a.Do()
 }
 
-// Relevant SSA:
-// func Baz(b B):
-//        t0 = local B (b)
-//        *t0 = b
-//        t1 = *t0
-//        t2 = NewA(t1)
-//        t3 = (*A).Do(t2)
-//        return
-//
-// func (a *A) Do():
-//        t0 = &a.I [#0]
-//        t1 = *t0
-//        t2 = invoke t1.Foo()
-//        return
-//
-// Name: (testdata.A).Foo
-// Synthetic: wrapper for func (testdata.I).Foo()
-// Location: testdata/callgraph_fields.go:10:2
-// func (arg0 testdata.A) Foo():
-//	  t0 = local testdata.A ()
-//        *t0 = arg0
-//        t1 = &t0.I [#0]
-//        t2 = *t1
-//        t3 = invoke t2.Foo()
-//        return
-//
-// Name: (*testdata.A).Foo
-// Synthetic: wrapper for func (testdata.I).Foo()
-// Location: testdata/callgraph_fields.go:10:2
-// func (arg0 *testdata.A) Foo():
-//        t0 = &arg0.I [#0]
-//        t1 = *t0
-//        t2 = invoke t1.Foo()
-//        return
-//
-// func (b B) Foo():
-//        t0 = local B (b)
-//        *t0 = b
-//        return
-//
-// func (b *testdata.B) Foo():
-//        t0 = ssa:wrapnilchk(b, "testdata.B":string, "Foo":string)
-//        t1 = *t0
-//        t2 = (testdata.B).Foo(t1)
-//        return
-//
-// func NewA(b B) *A:
-//        t0 = new B (b)
-//        *t0 = b
-//        t1 = new A (complit)
-//        t2 = &t1.I [#0]
-//        t3 = make I <- *B (t0)
-//        *t2 = t3
-//        return t1
-
 // WANT:
-// Baz: (*A).Do(t2) -> A.Do; NewA(t1) -> NewA
+// Baz: (*A).Do(t0) -> A.Do; NewA(b) -> NewA
 // A.Do: invoke t1.Foo() -> B.Foo

go/callgraph/vta/testdata/src/callgraph_generics.go

@@ -39,33 +39,24 @@ func Foo(a A, b B) {
 
 // Relevant SSA:
 //func Foo(a A, b B):
-//  t0 = local A (a)
-//  *t0 = a
-//  t1 = local B (b)
-//  *t1 = b
-//  t2 = new bool (x)
-//  *t2 = true:bool
-//  t3 = instantiated[bool](t2)
-//  t4 = new int (y)
-//  *t4 = 1:int
-//  t5 = instantiated[int](t4)
-//  t6 = *t0
-//  t7 = interfaceInstantiated[testdata.A](t6)
-//  t8 = *t1
-//  t9 = interfaceInstantiated[testdata.B](t8)
+//  t0 = new bool (x)
+//  *t0 = true:bool
+//  t1 = instantiated[bool](t2)
+//  t1 = new int (y)
+//  *t2 = 1:int
+//  t3 = instantiated[[int]](t4)
+//  t4 = interfaceInstantiated[testdata.A](a)
+//  t5 = interfaceInstantiated[testdata.B](b)
 //  return
 //
-//func interfaceInstantiated[testdata.B](x B):
-//  t0 = local B (x)
-//  *t0 = x
-//  t1 = *t0
-//  t2 = (B).Bar(t1)
+//func interfaceInstantiated[[testdata.B]](x B):
+//  t0 = (B).Bar(b)
 //  return
 //
 //func interfaceInstantiated[X I](x X):
 //        (external)
 
 // WANT:
-// Foo: instantiated[bool](t2) -> instantiated[bool]; instantiated[int](t4) -> instantiated[int]; interfaceInstantiated[testdata.A](t6) -> interfaceInstantiated[testdata.A]; interfaceInstantiated[testdata.B](t8) -> interfaceInstantiated[testdata.B]
-// interfaceInstantiated[testdata.B]: (B).Bar(t1) -> B.Bar
-// interfaceInstantiated[testdata.A]: (A).Bar(t1) -> A.Bar
+// Foo: instantiated[bool](t0) -> instantiated[bool]; instantiated[int](t2) -> instantiated[int]; interfaceInstantiated[testdata.A](a) -> interfaceInstantiated[testdata.A]; interfaceInstantiated[testdata.B](b) -> interfaceInstantiated[testdata.B]
+// interfaceInstantiated[testdata.B]: (B).Bar(x) -> B.Bar
+// interfaceInstantiated[testdata.A]: (A).Bar(x) -> A.Bar

go/callgraph/vta/testdata/src/callgraph_interfaces.go

@@ -49,13 +49,11 @@ func Baz(b bool) {
 
 // func Do(b bool) I:
 //    ...
-//   t3 = local C (c)
-//   t4 = *t3
-//   t5 = (C).Foo(t4)
-//   t6 = NewB()
-//   t7 = make I <- B (t6)
-//   return t7
+//   t1 = (C).Foo(struct{}{}:C)
+//   t2 = NewB()
+//   t3 = make I <- B (t2)
+//   return t3
 
 // WANT:
 // Baz: Do(b) -> Do; invoke t0.Foo() -> A.Foo, B.Foo
-// Do: (C).Foo(t4) -> C.Foo; NewB() -> NewB
+// Do: (C).Foo(struct{}{}:C) -> C.Foo; NewB() -> NewB

go/callgraph/vta/testdata/src/callgraph_pointers.go

@@ -35,37 +35,9 @@ func Baz(a A, b B, c bool) {
 	(*x).Foo()
 }
 
-// Relevant SSA:
-// func Baz(a A, b B, c bool):
-//   t0 = local A (a)
-//   ...
-//   t5 = Do(t2, t4, c)
-//   t6 = *t5
-//   t7 = invoke t6.Foo()
-//   return
-
-// func Do(a A, i I, c bool) *I:
-//   t0 = local A (a)
-//   *t0 = a
-//   ...
-//   if c goto 1 else 3
-//  1:
-//   t2 = &t0.f [#0]
-//   ...
-//   jump 2
-//  2:
-//   t6 = &t0.f [#0]
-//   ...
-//   t9 = invoke t8.Foo()
-//   return t1
-//  3:
-//   t10 = &t0.f [#0]      alias between A.f and t10
-//   *t10 = t1             alias between t10 and t1
-//   jump 2
-
 // The command a.f = &i introduces aliasing that results in
 // A and B reaching both *A.f and return value of Do(a, b, c).
 
 // WANT:
-// Baz: Do(t2, t4, c) -> Do; invoke t6.Foo() -> A.Foo, B.Foo
+// Baz: Do(a, t0, c) -> Do; invoke t2.Foo() -> A.Foo, B.Foo
 // Do: invoke t8.Foo() -> A.Foo, B.Foo

go/callgraph/vta/testdata/src/callgraph_static.go

@@ -20,11 +20,9 @@ func Baz(a A) {
 
 // Relevant SSA:
 // func Baz(a A):
-//   ...
-//   t2 = (A).foo(t1)
-//   t3 = Bar()
-//   ...
-//   t6 = Baz(t5)
+//   t0 = (A).foo(a)
+//   t1 = Bar()
+//   t2 = Baz(struct{}{}:A)
 
 // WANT:
-// Baz: (A).foo(t1) -> A.foo; Bar() -> Bar; Baz(t5) -> Baz
+// Baz: (A).foo(a) -> A.foo; Bar() -> Bar; Baz(struct{}{}:A) -> Baz

go/callgraph/vta/testdata/src/dynamic_calls.go

@@ -27,23 +27,22 @@ func Baz(x B, h func() I, i I) I {
 	return h()
 }
 
+var g *B = &B{} // ensure *B.foo is created.
+
 // Relevant SSA:
 // func Baz(x B, h func() I, i I) I:
-//   t0 = local B (x)
-//   *t0 = x
-//   t1 = *t0
-//   t2 = make I <- B (t1)
-//   t3 = invoke i.foo(t2)
-//   t4 = h()
-//   return t4
-
-// Local(t2) has seemingly duplicates of successors. This
+//   t0 = make I <- B (x)
+//   t1 = invoke i.foo(t0)
+//   t2 = h()
+//   return t2
+
+// Local(t0) has seemingly duplicates of successors. This
 // happens in stringification of type propagation graph.
 // Due to CHA, we analyze A.foo and *A.foo as well as B.foo
 // and *B.foo, which have similar bodies and hence similar
 // type flow that gets merged together during stringification.
 
 // WANT:
-// Local(t2) -> Local(ai), Local(ai), Local(bi), Local(bi)
-// Constant(testdata.I) -> Local(t4)
-// Local(t1) -> Local(t2)
+// Local(t0) -> Local(ai), Local(ai), Local(bi), Local(bi)
+// Constant(testdata.I) -> Local(t2)
+// Local(x) -> Local(t0)

go/callgraph/vta/testdata/src/maps.go

@@ -30,23 +30,16 @@ func Baz(m map[I]I, b1, b2 B, n map[string]*J) *J {
 
 // Relevant SSA:
 // func Baz(m map[I]I, b1 B, b2 B, n map[string]*J) *J:
-//   t0 = local B (b1)
-//   *t0 = b1
-//   t1 = local B (b2)
-//   *t1 = b2
-//   t2 = *t0
-//   t3 = make I <- B (t2)
-//   t4 = *t1
-//   t5 = make I <- B (t4)
-//   m[t3] = t5
-//   t6 = *t0
-//   t7 = (B).Foo(t6)
-//   t8 = n[t7]
-//   return t8
+//   t0 = make I <- B (b1)
+//   t1 = make I <- B (b2)
+//   m[t0] = t1
+//   t2 = (B).Foo(b1)
+//   t3 = n[t2]
+//   return t3
 
 // WANT:
-// Local(t4) -> Local(t5)
-// Local(t5) -> MapValue(testdata.I)
-// Local(t3) -> MapKey(testdata.I)
-// Local(t8) -> MapValue(*testdata.J)
-// MapValue(*testdata.J) -> Local(t8)
+// Local(b2) -> Local(t1)
+// Local(t1) -> MapValue(testdata.I)
+// Local(t0) -> MapKey(testdata.I)
+// Local(t3) -> MapValue(*testdata.J)
+// MapValue(*testdata.J) -> Local(t3)

go/callgraph/vta/testdata/src/panic.go

@@ -50,18 +50,14 @@ func Baz(a A) {
 //   return
 //
 // func Baz(i I):
-//   t0 = local A (a)
-//   *t0 = a
 //   defer recover1()
-//   defer recover()
-//   t1 = *t0
-//   t2 = make interface{} <- A (t1)
+//   t0 = make interface{} <- A (a)
 //   panic t2
 
-// t2 argument to panic in Baz gets ultimately connected to recover
+// t0 argument to panic in Baz gets ultimately connected to recover
 // registers t1 in recover1() and t0 in recover2().
 
 // WANT:
 // Panic -> Recover
-// Local(t2) -> Panic
+// Local(t0) -> Panic
 // Recover -> Local(t0), Local(t1)