[dev.go2go] go/go2go: translate types to AST

We were relying on calling typeString and treating that as an AST ident,
with special handling for instantiated types, but that fails if there is
an instantiated type within a type literal.

Fixes #39881

Change-Id: I793fe359868d8d73e830aa8dc67cf52de99355a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/240197
Reviewed-by: Ian Lance Taylor <[email protected]>

Author: ianlancetaylor

src/go/go2go/instantiate.go

@@ -841,11 +841,10 @@ func (t *translator) instantiateExpr(ta *typeArgs, e ast.Expr) ast.Expr {
 			if isPtr {
 				instType = types.NewPointer(instType)
 			}
-			str := types.TypeString(instType, relativeTo(t.tpkg))
 			newField := &ast.Field{
 				Doc:     f.Doc,
 				Names:   []*ast.Ident{id},
-				Type:    ast.NewIdent(str),
+				Type:    t.typeToAST(instType),
 				Tag:     f.Tag,
 				Comment: f.Comment,
 			}

src/go/go2go/rewrite.go

@@ -771,6 +771,10 @@ func (t *translator) translateSelectorExpr(pe *ast.Expr) {
 		if fobj != nil && len(indexes) > 1 {
 			for _, index := range indexes[:len(indexes)-1] {
 				xf := xType.Struct().Field(index)
+				// This must be an embedded type.
+				// If the field name is the one we expect,
+				// don't mention it explicitly,
+				// because it might not be exported.
 				if xf.Name() == types.TypeString(xf.Type(), relativeTo(xf.Pkg())) {
 					continue
 				}
@@ -1168,22 +1172,7 @@ func (t *translator) typeWithoutArgs(typ *types.Named) *types.Named {
 func (t *translator) typeListToASTList(typeList []types.Type) ([]types.Type, []ast.Expr) {
 	argList := make([]ast.Expr, 0, len(typeList))
 	for _, typ := range typeList {
-		str := types.TypeString(typ, relativeTo(t.tpkg))
-		arg := ast.NewIdent("(" + str + ")")
-		if named, ok := typ.(*types.Named); ok {
-			if len(named.TArgs()) > 0 {
-				var narg *ast.Ident
-				_, narg = t.lookupInstantiatedType(named)
-				if t.err != nil {
-					return nil, nil
-				}
-				if narg != nil {
-					arg = ast.NewIdent(narg.Name)
-				}
-			}
-		}
-		argList = append(argList, arg)
-		t.setType(arg, typ)
+		argList = append(argList, t.typeToAST(typ))
 
 		// This inferred type may introduce a reference to
 		// packages that we don't otherwise import, and that

src/go/go2go/types.go

@@ -7,7 +7,10 @@ package go2go
 import (
 	"fmt"
 	"go/ast"
+	"go/token"
 	"go/types"
+	"strconv"
+	"strings"
 )
 
 // lookupType returns the types.Type for an AST expression.
@@ -27,13 +30,13 @@ func (t *translator) lookupType(e ast.Expr) types.Type {
 // Uninstantiated AST expressions will be listed in t.importer.info.Types.
 func (t *translator) setType(e ast.Expr, nt types.Type) {
 	if ot, ok := t.importer.info.Types[e]; ok {
-		if !types.IdenticalIgnoreTags(ot.Type, nt) {
+		if !t.sameType(ot.Type, nt) {
 			panic("expression type changed")
 		}
 		return
 	}
 	if ot, ok := t.types[e]; ok {
-		if !types.IdenticalIgnoreTags(ot, nt) {
+		if !t.sameType(ot, nt) {
 			panic("expression type changed")
 		}
 		return
@@ -459,3 +462,165 @@ func (t *translator) tupleWithoutTags(tuple *types.Tuple) *types.Tuple {
 	}
 	return types.NewTuple(vars...)
 }
+
+// typeToAST converts a types.Type to an ast.Expr.
+func (t *translator) typeToAST(typ types.Type) ast.Expr {
+	var r ast.Expr
+	switch typ := typ.(type) {
+	case *types.Basic:
+		r = ast.NewIdent(typ.Name())
+	case *types.Array:
+		r = &ast.ArrayType{
+			Len: &ast.BasicLit{
+				Kind:  token.INT,
+				Value: strconv.FormatInt(typ.Len(), 10),
+			},
+			Elt: t.typeToAST(typ.Elem()),
+		}
+	case *types.Slice:
+		r = &ast.ArrayType{
+			Elt: t.typeToAST(typ.Elem()),
+		}
+	case *types.Struct:
+		var fields []*ast.Field
+		n := typ.NumFields()
+		for i := 0; i < n; i++ {
+			tf := typ.Field(i)
+			var names []*ast.Ident
+			if !tf.Embedded() {
+				names = []*ast.Ident{
+					ast.NewIdent(tf.Name()),
+				}
+			}
+			var atag *ast.BasicLit
+			if tag := typ.Tag(i); tag != "" {
+				atag = &ast.BasicLit{
+					Kind:  token.STRING,
+					Value: strconv.Quote(tag),
+				}
+			}
+			af := &ast.Field{
+				Names: names,
+				Type:  t.typeToAST(tf.Type()),
+				Tag:   atag,
+			}
+			fields = append(fields, af)
+		}
+		r = &ast.StructType{
+			Fields: &ast.FieldList{
+				List: fields,
+			},
+		}
+	case *types.Pointer:
+		r = &ast.StarExpr{
+			X: t.typeToAST(typ.Elem()),
+		}
+	case *types.Tuple:
+		// We should only see this in a types.Signature,
+		// where we handle it specially, since there is
+		// no ast.Expr that can represent this.
+		panic("unexpected types.Tuple")
+	case *types.Signature:
+		if len(typ.TParams()) > 0 {
+			// We should only see type parameters for
+			// a package scope function declaration.
+			panic("unexpected type parameters")
+		}
+		r = &ast.FuncType{
+			Params:  t.tupleToFieldList(typ.Params()),
+			Results: t.tupleToFieldList(typ.Params()),
+		}
+	case *types.Interface:
+		var methods []*ast.Field
+		nm := typ.NumExplicitMethods()
+		for i := 0; i < nm; i++ {
+			m := typ.ExplicitMethod(i)
+			f := &ast.Field{
+				Names: []*ast.Ident{
+					ast.NewIdent(m.Name()),
+				},
+				Type: t.typeToAST(m.Type()),
+			}
+			methods = append(methods, f)
+		}
+		ne := typ.NumEmbeddeds()
+		for i := 0; i < ne; i++ {
+			e := typ.EmbeddedType(i)
+			f := &ast.Field{
+				Type: t.typeToAST(e),
+			}
+			methods = append(methods, f)
+		}
+		r = &ast.InterfaceType{
+			Methods: &ast.FieldList{
+				List: methods,
+			},
+		}
+	case *types.Map:
+		r = &ast.MapType{
+			Key:   t.typeToAST(typ.Key()),
+			Value: t.typeToAST(typ.Elem()),
+		}
+	case *types.Chan:
+		var dir ast.ChanDir
+		switch typ.Dir() {
+		case types.SendRecv:
+			dir = ast.SEND | ast.RECV
+		case types.SendOnly:
+			dir = ast.SEND
+		case types.RecvOnly:
+			dir = ast.RECV
+		default:
+			panic("unsupported channel direction")
+		}
+		r = &ast.ChanType{
+			Dir:   dir,
+			Value: t.typeToAST(typ.Elem()),
+		}
+	case *types.Named:
+		if len(typ.TArgs()) > 0 {
+			_, id := t.lookupInstantiatedType(typ)
+			r = id
+		} else {
+			var sb strings.Builder
+			tn := typ.Obj()
+			if tn.Pkg() != nil && tn.Pkg() != t.tpkg {
+				sb.WriteString(tn.Pkg().Name())
+				sb.WriteByte('.')
+			}
+			sb.WriteString(tn.Name())
+			r = ast.NewIdent(sb.String())
+		}
+	case *types.TypeParam:
+		// This should have been instantiated already.
+		panic("unexpected type parameter")
+	default:
+		panic(fmt.Sprintf("unimplemented Type %T", typ))
+	}
+
+	t.setType(r, typ)
+	return r
+}
+
+// tupleToFieldList converts a tupes.Tuple to a ast.FieldList.
+func (t *translator) tupleToFieldList(tuple *types.Tuple) *ast.FieldList {
+	var fields []*ast.Field
+	n := tuple.Len()
+	for i := 0; i < n; i++ {
+		v := tuple.At(i)
+		var names []*ast.Ident
+		if v.Name() != "" {
+			names = []*ast.Ident{
+				ast.NewIdent(v.Name()),
+			}
+		}
+		f := &ast.Field{
+			Names: names,
+			Type:  t.typeToAST(v.Type()),
+		}
+		fields = append(fields, f)
+	}
+	return &ast.FieldList{
+		List: fields,
+	}
+}

test/gen/g027.go2

@@ -4,7 +4,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Issue 39678.
+// Issue 39678, 39881.
 package p
 
 type B(type T) struct {
@@ -20,3 +20,15 @@ type BC B(C)
 func F(s BC) {
 	s.F = 7
 }
+
+type Pair(type T, U) struct {
+	T
+	U
+}
+
+func (p Pair(T, U)) M() {
+	_, _ = p.T, p.U
+}
+
+var V1 Pair(Pair(int, int), int)
+var V2 Pair(struct { p Pair(int, int) }, int)