go/types/objectpath: add support for type parameters

This CL adds an initial draft of support for type parameters in the
go/types/objectpath package. For now, introduce two new operators:
 - the 'T' operator (type->type), which requires an integer operand and
   goes from *Named and *Signature types to the type parameter at the
   given index.
 - the 'C' operator (type->type), which goes from a *TypeParam type to
   its constraint.

Along the way, reorganize the path tests and update some errors messages
to consistently format the expected type with %T.

Fixes golang/go#48588

Change-Id: Ibdf03a86b7d8e24a8faa1f2fc42f2be8db20ca75
Reviewed-on: https://go-review.googlesource.com/c/tools/+/350148
Trust: Robert Findley <[email protected]>
Run-TryBot: Robert Findley <[email protected]>
TryBot-Result: Go Bot <[email protected]>
gopls-CI: kokoro <[email protected]>
Reviewed-by: Tim King <[email protected]>

Author: findleyr

go/types/objectpath/objectpath.go

@@ -27,6 +27,8 @@ import (
 	"strings"
 
 	"go/types"
+
+	"golang.org/x/tools/internal/typeparams"
 )
 
 // A Path is an opaque name that identifies a types.Object
@@ -57,7 +59,9 @@ type Path string
 // - The only PO operator is Package.Scope.Lookup, which requires an identifier.
 // - The only OT operator is Object.Type,
 //   which we encode as '.' because dot cannot appear in an identifier.
-// - The TT operators are encoded as [EKPRU].
+// - The TT operators are encoded as [EKPRUTC];
+//   one of these (TypeParam) requires an integer operand,
+//   which is encoded as a string of decimal digits.
 // - The TO operators are encoded as [AFMO];
 //   three of these (At,Field,Method) require an integer operand,
 //   which is encoded as a string of decimal digits.
@@ -89,17 +93,19 @@ const (
 	opType = '.' // .Type()		  (Object)
 
 	// type->type operators
-	opElem       = 'E' // .Elem()		(Pointer, Slice, Array, Chan, Map)
-	opKey        = 'K' // .Key()		(Map)
-	opParams     = 'P' // .Params()		(Signature)
-	opResults    = 'R' // .Results()	(Signature)
-	opUnderlying = 'U' // .Underlying()	(Named)
+	opElem       = 'E' // .Elem()		        (Pointer, Slice, Array, Chan, Map)
+	opKey        = 'K' // .Key()		        (Map)
+	opParams     = 'P' // .Params()		      (Signature)
+	opResults    = 'R' // .Results()	      (Signature)
+	opUnderlying = 'U' // .Underlying()	    (Named)
+	opTypeParam  = 'T' // .TypeParams.At(i) (Named, Signature)
+	opConstraint = 'C' // .Constraint()     (TypeParam)
 
 	// type->object operators
-	opAt     = 'A' // .At(i)		(Tuple)
-	opField  = 'F' // .Field(i)		(Struct)
-	opMethod = 'M' // .Method(i)		(Named or Interface; not Struct: "promoted" names are ignored)
-	opObj    = 'O' // .Obj()		(Named)
+	opAt     = 'A' // .At(i)		 (Tuple)
+	opField  = 'F' // .Field(i)	 (Struct)
+	opMethod = 'M' // .Method(i) (Named or Interface; not Struct: "promoted" names are ignored)
+	opObj    = 'O' // .Obj()		 (Named, TypeParam)
 )
 
 // The For function returns the path to an object relative to its package,
@@ -190,10 +196,15 @@ func For(obj types.Object) (Path, error) {
 	// 3. Not a package-level object.
 	//    Reject obviously non-viable cases.
 	switch obj := obj.(type) {
+	case *types.TypeName:
+		if _, ok := obj.Type().(*typeparams.TypeParam); !ok {
+			// With the exception of type parameters, only package-level type names
+			// have a path.
+			return "", fmt.Errorf("no path for %v", obj)
+		}
 	case *types.Const, // Only package-level constants have a path.
-		*types.TypeName, // Only package-level types have a path.
-		*types.Label,    // Labels are function-local.
-		*types.PkgName:  // PkgNames are file-local.
+		*types.Label,   // Labels are function-local.
+		*types.PkgName: // PkgNames are file-local.
 		return "", fmt.Errorf("no path for %v", obj)
 
 	case *types.Var:
@@ -245,6 +256,12 @@ func For(obj types.Object) (Path, error) {
 				return Path(r), nil
 			}
 		} else {
+			if named, _ := T.(*types.Named); named != nil {
+				if r := findTypeParam(obj, typeparams.ForNamed(named), path); r != nil {
+					// generic named type
+					return Path(r), nil
+				}
+			}
 			// defined (named) type
 			if r := find(obj, T.Underlying(), append(path, opUnderlying)); r != nil {
 				return Path(r), nil
@@ -313,6 +330,9 @@ func find(obj types.Object, T types.Type, path []byte) []byte {
 		}
 		return find(obj, T.Elem(), append(path, opElem))
 	case *types.Signature:
+		if r := findTypeParam(obj, typeparams.ForSignature(T), path); r != nil {
+			return r
+		}
 		if r := find(obj, T.Params(), append(path, opParams)); r != nil {
 			return r
 		}
@@ -353,10 +373,30 @@ func find(obj types.Object, T types.Type, path []byte) []byte {
 			}
 		}
 		return nil
+	case *typeparams.TypeParam:
+		name := T.Obj()
+		if name == obj {
+			return append(path, opObj)
+		}
+		if r := find(obj, T.Constraint(), append(path, opConstraint)); r != nil {
+			return r
+		}
+		return nil
 	}
 	panic(T)
 }
 
+func findTypeParam(obj types.Object, list *typeparams.TypeParamList, path []byte) []byte {
+	for i := 0; i < list.Len(); i++ {
+		tparam := list.At(i)
+		path2 := appendOpArg(path, opTypeParam, i)
+		if r := find(obj, tparam, path2); r != nil {
+			return r
+		}
+	}
+	return nil
+}
+
 // Object returns the object denoted by path p within the package pkg.
 func Object(pkg *types.Package, p Path) (types.Object, error) {
 	if p == "" {
@@ -386,6 +426,14 @@ func Object(pkg *types.Package, p Path) (types.Object, error) {
 		Method(int) *types.Func
 		NumMethods() int
 	}
+	// abstraction of *types.{Named,Signature}
+	type hasTypeParams interface {
+		TypeParams() *typeparams.TypeParamList
+	}
+	// abstraction of *types.{Named,TypeParam}
+	type hasObj interface {
+		Obj() *types.TypeName
+	}
 
 	// The loop state is the pair (t, obj),
 	// exactly one of which is non-nil, initially obj.
@@ -401,7 +449,7 @@ func Object(pkg *types.Package, p Path) (types.Object, error) {
 		// Codes [AFM] have an integer operand.
 		var index int
 		switch code {
-		case opAt, opField, opMethod:
+		case opAt, opField, opMethod, opTypeParam:
 			rest := strings.TrimLeft(suffix, "0123456789")
 			numerals := suffix[:len(suffix)-len(rest)]
 			suffix = rest
@@ -466,14 +514,32 @@ func Object(pkg *types.Package, p Path) (types.Object, error) {
 		case opUnderlying:
 			named, ok := t.(*types.Named)
 			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %s, want named)", code, t, t)
+				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named)", code, t, t)
 			}
 			t = named.Underlying()
 
+		case opTypeParam:
+			hasTypeParams, ok := t.(hasTypeParams) // Named, Signature
+			if !ok {
+				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named or signature)", code, t, t)
+			}
+			tparams := hasTypeParams.TypeParams()
+			if n := tparams.Len(); index >= n {
+				return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
+			}
+			t = tparams.At(index)
+
+		case opConstraint:
+			tparam, ok := t.(*typeparams.TypeParam)
+			if !ok {
+				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want type parameter)", code, t, t)
+			}
+			t = tparam.Constraint()
+
 		case opAt:
 			tuple, ok := t.(*types.Tuple)
 			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %s, want tuple)", code, t, t)
+				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want tuple)", code, t, t)
 			}
 			if n := tuple.Len(); index >= n {
 				return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
@@ -495,7 +561,7 @@ func Object(pkg *types.Package, p Path) (types.Object, error) {
 		case opMethod:
 			hasMethods, ok := t.(hasMethods) // Interface or Named
 			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %s, want interface or named)", code, t, t)
+				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want interface or named)", code, t, t)
 			}
 			if n := hasMethods.NumMethods(); index >= n {
 				return nil, fmt.Errorf("method index %d out of range [0-%d)", index, n)
@@ -504,11 +570,11 @@ func Object(pkg *types.Package, p Path) (types.Object, error) {
 			t = nil
 
 		case opObj:
-			named, ok := t.(*types.Named)
+			hasObj, ok := t.(hasObj)
 			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %s, want named)", code, t, t)
+				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named or type param)", code, t, t)
 			}
-			obj = named.Obj()
+			obj = hasObj.Obj()
 			t = nil
 
 		default:

go/types/objectpath/objectpath_go118_test.go

@@ -0,0 +1,93 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.18
+// +build go1.18
+
+package objectpath_test
+
+import (
+	"go/types"
+	"testing"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/types/objectpath"
+)
+
+func TestGenericPaths(t *testing.T) {
+	pkgs := map[string]map[string]string{
+		"b": {"b.go": `
+package b
+
+const C int = 1
+
+type T[TP0 any, TP1 interface{ M0(); M1() }] struct{}
+
+func (T[RP0, RP1]) M() {}
+
+type N int
+
+func (N) M0()
+func (N) M1()
+
+type A = T[int, N]
+
+func F[FP0, FP1 any](FP0, FP1) {}
+`},
+	}
+	paths := []pathTest{
+		// Good paths
+		{"b", "T", "type b.T[b.TP0 interface{}, b.TP1 interface{M0(); M1()}] struct{}", ""},
+		{"b", "T.O", "type b.T[b.TP0 interface{}, b.TP1 interface{M0(); M1()}] struct{}", ""},
+		{"b", "T.M0", "func (b.T[b.RP0, b.RP1]).M()", ""},
+		{"b", "T.T0O", "type TP0 = b.TP0", ""},
+		{"b", "T.T1O", "type TP1 = b.TP1", ""},
+		{"b", "T.T1CM0", "func (interface).M0()", ""},
+		// Obj of an instance is the generic declaration.
+		{"b", "A.O", "type b.T[b.TP0 interface{}, b.TP1 interface{M0(); M1()}] struct{}", ""},
+		{"b", "A.M0", "func (b.T[int, b.N]).M()", ""},
+
+		// Bad paths
+		{"b", "N.C", "", "invalid path: ends with 'C', want [AFMO]"},
+		{"b", "N.CO", "", "cannot apply 'C' to b.N (got *types.Named, want type parameter)"},
+		{"b", "N.T", "", `invalid path: bad numeric operand "" for code 'T'`},
+		{"b", "N.T0", "", "tuple index 0 out of range [0-0)"},
+		{"b", "T.T2O", "", "tuple index 2 out of range [0-2)"},
+		{"b", "T.T1M0", "", "cannot apply 'M' to b.TP1 (got *types.TypeParam, want interface or named)"},
+		{"b", "C.T0", "", "cannot apply 'T' to int (got *types.Basic, want named or signature)"},
+	}
+
+	conf := loader.Config{Build: buildutil.FakeContext(pkgs)}
+	conf.Import("b")
+	prog, err := conf.Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, test := range paths {
+		if err := testPath(prog, test); err != nil {
+			t.Error(err)
+		}
+	}
+
+	// bad objects
+	for _, test := range []struct {
+		obj     types.Object
+		wantErr string
+	}{
+		{types.Universe.Lookup("any"), "predeclared type any = interface{} has no path"},
+		{types.Universe.Lookup("comparable"), "predeclared type comparable interface{} has no path"},
+	} {
+		path, err := objectpath.For(test.obj)
+		if err == nil {
+			t.Errorf("Object(%s) = %q, want error", test.obj, path)
+			continue
+		}
+		if err.Error() != test.wantErr {
+			t.Errorf("Object(%s) error was %q, want %q", test.obj, err, test.wantErr)
+			continue
+		}
+	}
+}