go/ssa: use core types for array length

Updates len, cap and range built-ins to use the array length
based on the core types of the array or pointer to array.

These are not constant in the language but can be treated as
constants during translation.

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

Author: timothy-king

go/ssa/builder.go

@@ -373,10 +373,8 @@ func (b *builder) builtin(fn *Function, obj *types.Builtin, args []ast.Expr, typ
 		// We must still evaluate the value, though.  (If it
 		// was side-effect free, the whole call would have
 		// been constant-folded.)
-		//
-		// Type parameters are always non-constant so use Underlying.
-		t, _ := deptr(fn.typeOf(args[0]))
-		if at, ok := t.Underlying().(*types.Array); ok {
+		t, _ := deref(fn.typeOf(args[0]))
+		if at, ok := typeparams.CoreType(t).(*types.Array); ok {
 			b.expr(fn, args[0]) // for effects only
 			return intConst(at.Len())
 		}
@@ -1884,17 +1882,14 @@ func (b *builder) rangeIndexed(fn *Function, x Value, tv types.Type, pos token.P
 
 	// Determine number of iterations.
 	var length Value
-	dt, _ := deptr(x.Type())
-	if arr, ok := dt.Underlying().(*types.Array); ok {
+	dt, _ := deref(x.Type())
+	if arr, ok := typeparams.CoreType(dt).(*types.Array); ok {
 		// For array or *array, the number of iterations is
 		// known statically thanks to the type.  We avoid a
 		// data dependence upon x, permitting later dead-code
 		// elimination if x is pure, static unrolling, etc.
 		// Ranging over a nil *array may have >0 iterations.
 		// We still generate code for x, in case it has effects.
-		//
-		// TypeParams do not have constant length. Use underlying instead of core type.
-		// TODO: check if needed.
 		length = intConst(arr.Len())
 	} else {
 		// length = len(x).

go/ssa/builder_generic_test.go

@@ -436,6 +436,57 @@ func TestGenericBodies(t *testing.T) {
 			c := *(any(v).(*C)); print(c)  /*@ types("p23.C")*/
 		}
 		`,
+		`
+		package p24
+
+		func a[T any](f func() [4]T) {
+			x := len(f())
+			print(x) /*@ types("int")*/
+		}
+
+		func b[T [4]any](f func() T) {
+			x := len(f())
+			print(x) /*@ types("int")*/
+		}
+
+		func c[T any](f func() *[4]T) {
+			x := len(f())
+			print(x) /*@ types("int")*/
+		}
+
+		func d[T *[4]any](f func() T) {
+			x := len(f())
+			print(x) /*@ types("int")*/
+		}
+		`,
+		`
+		package p25
+
+		func a[T any]() {
+			var f func() [4]T
+			for i, v := range f() {
+				print(i, v) /*@ types("int", "T")*/
+			}
+		}
+
+		func b[T [4]any](f func() T) {
+			for i, v := range f() {
+				print(i, v) /*@ types("int", "any")*/
+			}
+		}
+
+		func c[T any](f func() *[4]T) {
+			for i, v := range f() {
+				print(i, v) /*@ types("int", "T")*/
+			}
+		}
+
+		func d[T *[4]any](f func() T) {
+			for i, v := range f() {
+				print(i, v) /*@ types("int", "any")*/
+			}
+		}
+		`,
 	} {
 		contents := contents
 		pkgname := packageName(t, contents)
@@ -465,15 +516,15 @@ func TestGenericBodies(t *testing.T) {
 			p.Build()
 
 			// Collect calls to the builtin print function.
-			probes := make(map[*ssa.CallCommon]bool)
+			probes := make(map[*ssa.CallCommon]*ssa.Function)
 			for _, mem := range p.Members {
 				if fn, ok := mem.(*ssa.Function); ok {
 					for _, bb := range fn.Blocks {
 						for _, i := range bb.Instrs {
 							if i, ok := i.(ssa.CallInstruction); ok {
 								call := i.Common()
 								if b, ok := call.Value.(*ssa.Builtin); ok && b.Name() == "print" {
-									probes[i.Common()] = true
+									probes[i.Common()] = fn
 								}
 							}
 						}
@@ -517,6 +568,7 @@ func TestGenericBodies(t *testing.T) {
 				}
 				if got, want := fmt.Sprint(args), fmt.Sprint(note.Args); got != want {
 					t.Errorf("Arguments to print() were expected to be %q. got %q", want, got)
+					logFunction(t, probes[call])
 				}
 			}
 		})
@@ -568,6 +620,14 @@ func TestInstructionString(t *testing.T) {
 		_ = x.foo
 		_ = x.foo()
 	}
+
+	//@ instrs("f4", "*ssa.BinOp", "t1 + 1:int", "t2 < 4:int")
+	//@ instrs("f4", "*ssa.Call", "f()", "print(t2, t4)")
+	func f4[T [4]string](f func() T) {
+		for i, v := range f() {
+			print(i, v)
+		}
+	}
 	`
 
 	// Parse