cmd/compile: getting more built-ins to work with generics

For Builtin ops, we currently stay with using the old
typechecker to transform the call to a more specific expression
and possibly use more specific ops. However, for a bunch of the
ops, we delay calling the old typechecker if any of the args have
type params, for a variety of reasons.

In the near future, we will start creating separate functions that do
the same transformations as the old typechecker for calls, builtins,
indexing, comparisons, etc. These functions can then be called at noder
time for nodes with no type params, and at stenciling time for nodes
with type params.

Remove unnecessary calls to types1 typechecker for most kinds of
statements (still need it for SendStmt, AssignStmt, ReturnStmt, and
SelectStmt). In particular, we don't need it for RangeStmt, and this
avoids some complaints by the types1 typechecker on generic code.

Other small changes:
 - Fix check on whether to delay calling types1-typechecker on type
   conversions. Should check if HasTParam is true, rather than if the
   type is directly a TYPEPARAM.

 - Don't call types1-typechecker on an indexing operation if the left
   operand has a typeparam in its type and is not obviously a TMAP,
   TSLICE, or TARRAY. As above, we will eventually have to create a new
   function that can do the required transformations (for complicated
   cases) at noder time or stenciling time.

 - Copy n.BuiltinOp in subster.node()

 - The complex arithmetic example in absdiff.go now works.

 - Added new tests double.go and append.go

 - Added new example with a new() call in settable.go

Change-Id: I8f377afb6126cab1826bd3c2732aa8cdf1f7e0b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/301951
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>

1 files changed, 68 insertions, 48 deletions

diff --git a/test/typeparam/settable.go b/test/typeparam/settable.go
index 29874fb189..588166da85 100644
--- a/test/typeparam/settable.go
+++ b/test/typeparam/settable.go
@@ -14,44 +14,58 @@ import (
 // Various implementations of fromStrings().
 
 type _Setter[B any] interface {
-        Set(string)
+	Set(string)
 	type *B
 }
 
 // Takes two type parameters where PT = *T
 func fromStrings1[T any, PT _Setter[T]](s []string) []T {
-        result := make([]T, len(s))
-        for i, v := range s {
-                // The type of &result[i] is *T which is in the type list
-                // of Setter, so we can convert it to PT.
-                p := PT(&result[i])
-                // PT has a Set method.
-                p.Set(v)
-        }
-        return result
+	result := make([]T, len(s))
+	for i, v := range s {
+		// The type of &result[i] is *T which is in the type list
+		// of Setter, so we can convert it to PT.
+		p := PT(&result[i])
+		// PT has a Set method.
+		p.Set(v)
+	}
+	return result
 }
 
+func fromStrings1a[T any, PT _Setter[T]](s []string) []PT {
+	result := make([]PT, len(s))
+	for i, v := range s {
+		// The type new(T) is *T which is in the type list
+		// of Setter, so we can convert it to PT.
+		result[i] = PT(new(T))
+		p := result[i]
+		// PT has a Set method.
+		p.Set(v)
+	}
+	return result
+}
+
+
 // Takes one type parameter and a set function
 func fromStrings2[T any](s []string, set func(*T, string)) []T {
-        results := make([]T, len(s))
-        for i, v := range s {
-                set(&results[i], v)
-        }
-        return results
+	results := make([]T, len(s))
+	for i, v := range s {
+		set(&results[i], v)
+	}
+	return results
 }
 
 type _Setter2 interface {
-        Set(string)
+	Set(string)
 }
 
 // Takes only one type parameter, but causes a panic (see below)
 func fromStrings3[T _Setter2](s []string) []T {
-        results := make([]T, len(s))
-        for i, v := range s {
+	results := make([]T, len(s))
+	for i, v := range s {
 		// Panics if T is a pointer type because receiver is T(nil).
 		results[i].Set(v)
-        }
-        return results
+	}
+	return results
 }
 
 // Two concrete types with the appropriate Set method.
@@ -59,11 +73,11 @@ func fromStrings3[T _Setter2](s []string) []T {
 type SettableInt int
 
 func (p *SettableInt) Set(s string) {
-        i, err := strconv.Atoi(s)
-        if err != nil {
-                panic(err)
-        }
-        *p = SettableInt(i)
+	i, err := strconv.Atoi(s)
+	if err != nil {
+		panic(err)
+	}
+	*p = SettableInt(i)
 }
 
 type SettableString struct {
@@ -71,34 +85,40 @@ type SettableString struct {
 }
 
 func (x *SettableString) Set(s string) {
-        x.s = s
+	x.s = s
 }
 
 func main() {
-        s := fromStrings1[SettableInt, *SettableInt]([]string{"1"})
-        if len(s) != 1 || s[0] != 1 {
-                panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
-        }
+	s := fromStrings1[SettableInt, *SettableInt]([]string{"1"})
+	if len(s) != 1 || s[0] != 1 {
+		panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
+	}
+
+	s2 := fromStrings1a[SettableInt, *SettableInt]([]string{"1"})
+	if len(s2) != 1 || *s2[0] != 1 {
+		x := 1
+		panic(fmt.Sprintf("got %v, want %v", s2, []*int{&x}))
+	}
 
 	// Test out constraint type inference, which should determine that the second
 	// type param is *SettableString.
 	ps := fromStrings1[SettableString]([]string{"x", "y"})
-        if len(ps) != 2 || ps[0] != (SettableString{"x"}) || ps[1] != (SettableString{"y"}) {
-                panic(s)
-        }
-
-        s = fromStrings2([]string{"1"}, func(p *SettableInt, s string) { p.Set(s) })
-        if len(s) != 1 || s[0] != 1 {
-                panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
-        }
-
-        defer func() {
-                if recover() == nil {
-                        panic("did not panic as expected")
-                }
-        }()
-        // This should type check but should panic at run time,
-        // because it will make a slice of *SettableInt and then call
-        // Set on a nil value.
-        fromStrings3[*SettableInt]([]string{"1"})
+	if len(ps) != 2 || ps[0] != (SettableString{"x"}) || ps[1] != (SettableString{"y"}) {
+		panic(s)
+	}
+
+	s = fromStrings2([]string{"1"}, func(p *SettableInt, s string) { p.Set(s) })
+	if len(s) != 1 || s[0] != 1 {
+		panic(fmt.Sprintf("got %v, want %v", s, []int{1}))
+	}
+
+	defer func() {
+		if recover() == nil {
+			panic("did not panic as expected")
+		}
+	}()
+	// This should type check but should panic at run time,
+	// because it will make a slice of *SettableInt and then call
+	// Set on a nil value.
+	fromStrings3[*SettableInt]([]string{"1"})
 }