util/codegen, cmd/cloner, cmd/viewer: update codegen.LookupMethod to support alias type nodes

Go 1.23 updates the go/types package to produce Alias type nodes for type aliases, unless disabled with gotypesalias=0.
This new default behavior breaks codegen.LookupMethod, which uses checked type assertions to types.Named and
types.Interface, as only named types and interfaces have methods.

In this PR, we update codegen.LookupMethod to perform method lookup on the right-hand side of the alias declaration
and clearly switch on the supported type nodes types. We also improve support for various edge cases, such as when an alias
is used as a type parameter constraint, and add tests for the LookupMethod function.

Additionally, we update cmd/viewer/tests to include types with aliases used in type fields and generic type constraints.

Updates #13224
Updates #12912

Signed-off-by: Nick Khyl <nickk@tailscale.com>

cmd/cloner/cloner.go

@@ -47,7 +47,7 @@ func main() {
 	it := codegen.NewImportTracker(pkg.Types)
 	buf := new(bytes.Buffer)
 	for _, typeName := range typeNames {
-		typ, ok := namedTypes[typeName]
+		typ, ok := namedTypes[typeName].(*types.Named)
 		if !ok {
 			log.Fatalf("could not find type %s", typeName)
 		}

cmd/viewer/tests/tests.go

@@ -13,7 +13,7 @@ import (
 	"tailscale.com/types/views"
 )
 
-//go:generate go run tailscale.com/cmd/viewer --type=StructWithPtrs,StructWithoutPtrs,Map,StructWithSlices,OnlyGetClone,StructWithEmbedded,GenericIntStruct,GenericNoPtrsStruct,GenericCloneableStruct,StructWithContainers --clone-only-type=OnlyGetClone
+//go:generate go run tailscale.com/cmd/viewer --type=StructWithPtrs,StructWithoutPtrs,Map,StructWithSlices,OnlyGetClone,StructWithEmbedded,GenericIntStruct,GenericNoPtrsStruct,GenericCloneableStruct,StructWithContainers,StructWithTypeAliasFields,GenericTypeAliasStruct --clone-only-type=OnlyGetClone
 
 type StructWithoutPtrs struct {
 	Int int
@@ -202,3 +202,20 @@ type StructWithContainers struct {
 	CloneableMap              MapContainer[int, *StructWithPtrs]
 	CloneableGenericMap       MapContainer[int, *GenericNoPtrsStruct[int]]
 }
+
+type (
+	StructWithPtrsAlias    = StructWithPtrs
+	StructWithoutPtrsAlias = StructWithoutPtrs
+)
+
+type StructWithTypeAliasFields struct {
+	WithPtr    StructWithPtrsAlias
+	WithoutPtr StructWithoutPtrsAlias
+}
+
+type integer = constraints.Integer
+
+type GenericTypeAliasStruct[T integer, T2 views.ViewCloner[T2, V2], V2 views.StructView[T2]] struct {
+	NonCloneable T
+	Cloneable    T2
+}

cmd/viewer/tests/tests_clone.go

@@ -441,3 +441,41 @@ var _StructWithContainersCloneNeedsRegeneration = StructWithContainers(struct {
 	CloneableMap              MapContainer[int, *StructWithPtrs]
 	CloneableGenericMap       MapContainer[int, *GenericNoPtrsStruct[int]]
 }{})
+
+// Clone makes a deep copy of StructWithTypeAliasFields.
+// The result aliases no memory with the original.
+func (src *StructWithTypeAliasFields) Clone() *StructWithTypeAliasFields {
+	if src == nil {
+		return nil
+	}
+	dst := new(StructWithTypeAliasFields)
+	*dst = *src
+	panic("TODO: WithPtr (*types.Struct)")
+	return dst
+}
+
+// A compilation failure here means this code must be regenerated, with the command at the top of this file.
+var _StructWithTypeAliasFieldsCloneNeedsRegeneration = StructWithTypeAliasFields(struct {
+	WithPtr    StructWithPtrsAlias
+	WithoutPtr StructWithoutPtrsAlias
+}{})
+
+// Clone makes a deep copy of GenericTypeAliasStruct.
+// The result aliases no memory with the original.
+func (src *GenericTypeAliasStruct[T, T2, V2]) Clone() *GenericTypeAliasStruct[T, T2, V2] {
+	if src == nil {
+		return nil
+	}
+	dst := new(GenericTypeAliasStruct[T, T2, V2])
+	*dst = *src
+	dst.Cloneable = src.Cloneable.Clone()
+	return dst
+}
+
+// A compilation failure here means this code must be regenerated, with the command at the top of this file.
+func _GenericTypeAliasStructCloneNeedsRegeneration[T integer, T2 views.ViewCloner[T2, V2], V2 views.StructView[T2]](GenericTypeAliasStruct[T, T2, V2]) {
+	_GenericTypeAliasStructCloneNeedsRegeneration(struct {
+		NonCloneable T
+		Cloneable    T2
+	}{})
+}

cmd/viewer/tests/tests_view.go

@@ -14,7 +14,7 @@ import (
 	"tailscale.com/types/views"
 )
 
-//go:generate go run tailscale.com/cmd/cloner  -clonefunc=false -type=StructWithPtrs,StructWithoutPtrs,Map,StructWithSlices,OnlyGetClone,StructWithEmbedded,GenericIntStruct,GenericNoPtrsStruct,GenericCloneableStruct,StructWithContainers
+//go:generate go run tailscale.com/cmd/cloner  -clonefunc=false -type=StructWithPtrs,StructWithoutPtrs,Map,StructWithSlices,OnlyGetClone,StructWithEmbedded,GenericIntStruct,GenericNoPtrsStruct,GenericCloneableStruct,StructWithContainers,StructWithTypeAliasFields,GenericTypeAliasStruct
 
 // View returns a readonly view of StructWithPtrs.
 func (p *StructWithPtrs) View() StructWithPtrsView {
@@ -676,3 +676,115 @@ var _StructWithContainersViewNeedsRegeneration = StructWithContainers(struct {
 	CloneableMap              MapContainer[int, *StructWithPtrs]
 	CloneableGenericMap       MapContainer[int, *GenericNoPtrsStruct[int]]
 }{})
+
+// View returns a readonly view of StructWithTypeAliasFields.
+func (p *StructWithTypeAliasFields) View() StructWithTypeAliasFieldsView {
+	return StructWithTypeAliasFieldsView{ж: p}
+}
+
+// StructWithTypeAliasFieldsView provides a read-only view over StructWithTypeAliasFields.
+//
+// Its methods should only be called if `Valid()` returns true.
+type StructWithTypeAliasFieldsView struct {
+	// ж is the underlying mutable value, named with a hard-to-type
+	// character that looks pointy like a pointer.
+	// It is named distinctively to make you think of how dangerous it is to escape
+	// to callers. You must not let callers be able to mutate it.
+	ж *StructWithTypeAliasFields
+}
+
+// Valid reports whether underlying value is non-nil.
+func (v StructWithTypeAliasFieldsView) Valid() bool { return v.ж != nil }
+
+// AsStruct returns a clone of the underlying value which aliases no memory with
+// the original.
+func (v StructWithTypeAliasFieldsView) AsStruct() *StructWithTypeAliasFields {
+	if v.ж == nil {
+		return nil
+	}
+	return v.ж.Clone()
+}
+
+func (v StructWithTypeAliasFieldsView) MarshalJSON() ([]byte, error) { return json.Marshal(v.ж) }
+
+func (v *StructWithTypeAliasFieldsView) UnmarshalJSON(b []byte) error {
+	if v.ж != nil {
+		return errors.New("already initialized")
+	}
+	if len(b) == 0 {
+		return nil
+	}
+	var x StructWithTypeAliasFields
+	if err := json.Unmarshal(b, &x); err != nil {
+		return err
+	}
+	v.ж = &x
+	return nil
+}
+
+func (v StructWithTypeAliasFieldsView) WithPtr() StructWithPtrsView        { return v.ж.WithPtr.View() }
+func (v StructWithTypeAliasFieldsView) WithoutPtr() StructWithoutPtrsAlias { return v.ж.WithoutPtr }
+
+// A compilation failure here means this code must be regenerated, with the command at the top of this file.
+var _StructWithTypeAliasFieldsViewNeedsRegeneration = StructWithTypeAliasFields(struct {
+	WithPtr    StructWithPtrsAlias
+	WithoutPtr StructWithoutPtrsAlias
+}{})
+
+// View returns a readonly view of GenericTypeAliasStruct.
+func (p *GenericTypeAliasStruct[T, T2, V2]) View() GenericTypeAliasStructView[T, T2, V2] {
+	return GenericTypeAliasStructView[T, T2, V2]{ж: p}
+}
+
+// GenericTypeAliasStructView[T, T2, V2] provides a read-only view over GenericTypeAliasStruct[T, T2, V2].
+//
+// Its methods should only be called if `Valid()` returns true.
+type GenericTypeAliasStructView[T integer, T2 views.ViewCloner[T2, V2], V2 views.StructView[T2]] struct {
+	// ж is the underlying mutable value, named with a hard-to-type
+	// character that looks pointy like a pointer.
+	// It is named distinctively to make you think of how dangerous it is to escape
+	// to callers. You must not let callers be able to mutate it.
+	ж *GenericTypeAliasStruct[T, T2, V2]
+}
+
+// Valid reports whether underlying value is non-nil.
+func (v GenericTypeAliasStructView[T, T2, V2]) Valid() bool { return v.ж != nil }
+
+// AsStruct returns a clone of the underlying value which aliases no memory with
+// the original.
+func (v GenericTypeAliasStructView[T, T2, V2]) AsStruct() *GenericTypeAliasStruct[T, T2, V2] {
+	if v.ж == nil {
+		return nil
+	}
+	return v.ж.Clone()
+}
+
+func (v GenericTypeAliasStructView[T, T2, V2]) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.ж)
+}
+
+func (v *GenericTypeAliasStructView[T, T2, V2]) UnmarshalJSON(b []byte) error {
+	if v.ж != nil {
+		return errors.New("already initialized")
+	}
+	if len(b) == 0 {
+		return nil
+	}
+	var x GenericTypeAliasStruct[T, T2, V2]
+	if err := json.Unmarshal(b, &x); err != nil {
+		return err
+	}
+	v.ж = &x
+	return nil
+}
+
+func (v GenericTypeAliasStructView[T, T2, V2]) NonCloneable() T { return v.ж.NonCloneable }
+func (v GenericTypeAliasStructView[T, T2, V2]) Cloneable() V2   { return v.ж.Cloneable.View() }
+
+// A compilation failure here means this code must be regenerated, with the command at the top of this file.
+func _GenericTypeAliasStructViewNeedsRegeneration[T integer, T2 views.ViewCloner[T2, V2], V2 views.StructView[T2]](GenericTypeAliasStruct[T, T2, V2]) {
+	_GenericTypeAliasStructViewNeedsRegeneration(struct {
+		NonCloneable T
+		Cloneable    T2
+	}{})
+}

cmd/viewer/viewer.go

@@ -567,7 +567,7 @@ func main() {
 		if cloneOnlyType[typeName] {
 			continue
 		}
-		typ, ok := namedTypes[typeName]
+		typ, ok := namedTypes[typeName].(*types.Named)
 		if !ok {
 			log.Fatalf("could not find type %s", typeName)
 		}

util/codegen/codegen.go

@@ -24,7 +24,7 @@ import (
 var flagCopyright = flag.Bool("copyright", true, "add Tailscale copyright to generated file headers")
 
 // LoadTypes returns all named types in pkgName, keyed by their type name.
-func LoadTypes(buildTags string, pkgName string) (*packages.Package, map[string]*types.Named, error) {
+func LoadTypes(buildTags string, pkgName string) (*packages.Package, map[string]types.Type, error) {
 	cfg := &packages.Config{
 		Mode:  packages.NeedTypes | packages.NeedTypesInfo | packages.NeedSyntax | packages.NeedName,
 		Tests: buildTags == "test",
@@ -181,8 +181,8 @@ func writeFormatted(code []byte, path string) error {
 }
 
 // namedTypes returns all named types in pkg, keyed by their type name.
-func namedTypes(pkg *packages.Package) map[string]*types.Named {
+func namedTypes(pkg *packages.Package) map[string]types.Type {
-	nt := make(map[string]*types.Named)
+	nt := make(map[string]types.Type)
 	for _, file := range pkg.Syntax {
 		for _, d := range file.Decls {
 			decl, ok := d.(*ast.GenDecl)
@@ -198,11 +198,10 @@ func namedTypes(pkg *packages.Package) map[string]*types.Named {
 				if !ok {
 					continue
 				}
-				typ, ok := typeNameObj.Type().(*types.Named)
+				switch typ := typeNameObj.Type(); typ.(type) {
-				if !ok {
+				case *types.Alias, *types.Named:
-					continue
+					nt[spec.Name.Name] = typ
 				}
-				nt[spec.Name.Name] = typ
 			}
 		}
 	}
@@ -356,14 +355,25 @@ func FormatTypeParams(params *types.TypeParamList, it *ImportTracker) (constrain
 
 // LookupMethod returns the method with the specified name in t, or nil if the method does not exist.
 func LookupMethod(t types.Type, name string) *types.Func {
-	if t, ok := t.(*types.Named); ok {
+	switch t := t.(type) {
-		for i := 0; i < t.NumMethods(); i++ {
+	case *types.Alias:
-			if method := t.Method(i); method.Name() == name {
+		return LookupMethod(t.Rhs(), name)
-				return method
+	case *types.TypeParam:
+		return LookupMethod(t.Constraint(), name)
+	case *types.Pointer:
+		return LookupMethod(t.Elem(), name)
+	case *types.Named:
+		switch u := t.Underlying().(type) {
+		case *types.Interface:
+			return LookupMethod(u, name)
+		default:
+			for i := 0; i < t.NumMethods(); i++ {
+				if method := t.Method(i); method.Name() == name {
+					return method
+				}
 			}
 		}
-	}
+	case *types.Interface:
-	if t, ok := t.Underlying().(*types.Interface); ok {
 		for i := 0; i < t.NumMethods(); i++ {
 			if method := t.Method(i); method.Name() == name {
 				return method

util/codegen/codegen_test.go

@@ -4,10 +4,11 @@
 package codegen
 
 import (
+	"cmp"
 	"go/types"
-	"log"
 	"net/netip"
 	"strings"
+	"sync"
 	"testing"
 	"unsafe"
 
@@ -162,14 +163,9 @@ func TestGenericContainsPointers(t *testing.T) {
 		},
 	}
 
-	_, namedTypes, err := LoadTypes("test", ".")
-	if err != nil {
-		log.Fatal(err)
-	}
-
 	for _, tt := range tests {
 		t.Run(tt.typ, func(t *testing.T) {
-			typ := namedTypes[tt.typ]
+			typ := lookupTestType(t, tt.typ)
 			if isPointer := ContainsPointers(typ); isPointer != tt.wantPointer {
 				t.Fatalf("ContainsPointers: got %v, want: %v", isPointer, tt.wantPointer)
 			}
@@ -252,3 +248,199 @@ func TestAssertStructUnchanged(t *testing.T) {
 		})
 	}
 }
+
+type NamedType struct{}
+
+func (NamedType) Method() {}
+
+type NamedTypeAlias = NamedType
+
+type NamedInterface interface {
+	Method()
+}
+
+type NamedInterfaceAlias = NamedInterface
+
+type GenericType[T NamedInterface] struct {
+	TypeParamField    T
+	TypeParamPtrField *T
+}
+
+type GenericTypeWithAliasConstraint[T NamedInterfaceAlias] struct {
+	TypeParamField    T
+	TypeParamPtrField *T
+}
+
+func TestLookupMethod(t *testing.T) {
+	tests := []struct {
+		name          string
+		typ           types.Type
+		methodName    string
+		wantHasMethod bool
+		wantReceiver  types.Type
+	}{
+		{
+			name:          "NamedType/HasMethod",
+			typ:           lookupTestType(t, "NamedType"),
+			methodName:    "Method",
+			wantHasMethod: true,
+		},
+		{
+			name:          "NamedType/NoMethod",
+			typ:           lookupTestType(t, "NamedType"),
+			methodName:    "NoMethod",
+			wantHasMethod: false,
+		},
+		{
+			name:          "NamedTypeAlias/HasMethod",
+			typ:           lookupTestType(t, "NamedTypeAlias"),
+			methodName:    "Method",
+			wantHasMethod: true,
+			wantReceiver:  lookupTestType(t, "NamedType"),
+		},
+		{
+			name:          "NamedTypeAlias/NoMethod",
+			typ:           lookupTestType(t, "NamedTypeAlias"),
+			methodName:    "NoMethod",
+			wantHasMethod: false,
+		},
+		{
+			name:          "PtrToNamedType/HasMethod",
+			typ:           types.NewPointer(lookupTestType(t, "NamedType")),
+			methodName:    "Method",
+			wantHasMethod: true,
+			wantReceiver:  lookupTestType(t, "NamedType"),
+		},
+		{
+			name:          "PtrToNamedType/NoMethod",
+			typ:           types.NewPointer(lookupTestType(t, "NamedType")),
+			methodName:    "NoMethod",
+			wantHasMethod: false,
+		},
+		{
+			name:          "PtrToNamedTypeAlias/HasMethod",
+			typ:           types.NewPointer(lookupTestType(t, "NamedTypeAlias")),
+			methodName:    "Method",
+			wantHasMethod: true,
+			wantReceiver:  lookupTestType(t, "NamedType"),
+		},
+		{
+			name:          "PtrToNamedTypeAlias/NoMethod",
+			typ:           types.NewPointer(lookupTestType(t, "NamedTypeAlias")),
+			methodName:    "NoMethod",
+			wantHasMethod: false,
+		},
+		{
+			name:          "NamedInterface/HasMethod",
+			typ:           lookupTestType(t, "NamedInterface"),
+			methodName:    "Method",
+			wantHasMethod: true,
+		},
+		{
+			name:          "NamedInterface/NoMethod",
+			typ:           lookupTestType(t, "NamedInterface"),
+			methodName:    "NoMethod",
+			wantHasMethod: false,
+		},
+		{
+			name:          "Interface/HasMethod",
+			typ:           types.NewInterfaceType([]*types.Func{types.NewFunc(0, nil, "Method", types.NewSignatureType(nil, nil, nil, nil, nil, false))}, nil),
+			methodName:    "Method",
+			wantHasMethod: true,
+		},
+		{
+			name:          "Interface/NoMethod",
+			typ:           types.NewInterfaceType(nil, nil),
+			methodName:    "NoMethod",
+			wantHasMethod: false,
+		},
+		{
+			name:          "TypeParam/HasMethod",
+			typ:           lookupTestType(t, "GenericType").Underlying().(*types.Struct).Field(0).Type(),
+			methodName:    "Method",
+			wantHasMethod: true,
+			wantReceiver:  lookupTestType(t, "NamedInterface"),
+		},
+		{
+			name:          "TypeParam/NoMethod",
+			typ:           lookupTestType(t, "GenericType").Underlying().(*types.Struct).Field(0).Type(),
+			methodName:    "NoMethod",
+			wantHasMethod: false,
+		},
+		{
+			name:          "TypeParamPtr/HasMethod",
+			typ:           lookupTestType(t, "GenericType").Underlying().(*types.Struct).Field(1).Type(),
+			methodName:    "Method",
+			wantHasMethod: true,
+			wantReceiver:  lookupTestType(t, "NamedInterface"),
+		},
+		{
+			name:          "TypeParamPtr/NoMethod",
+			typ:           lookupTestType(t, "GenericType").Underlying().(*types.Struct).Field(1).Type(),
+			methodName:    "NoMethod",
+			wantHasMethod: false,
+		},
+		{
+			name:          "TypeParamWithAlias/HasMethod",
+			typ:           lookupTestType(t, "GenericTypeWithAliasConstraint").Underlying().(*types.Struct).Field(0).Type(),
+			methodName:    "Method",
+			wantHasMethod: true,
+			wantReceiver:  lookupTestType(t, "NamedInterface"),
+		},
+		{
+			name:          "TypeParamWithAlias/NoMethod",
+			typ:           lookupTestType(t, "GenericTypeWithAliasConstraint").Underlying().(*types.Struct).Field(0).Type(),
+			methodName:    "NoMethod",
+			wantHasMethod: false,
+		},
+		{
+			name:          "TypeParamWithAliasPtr/HasMethod",
+			typ:           lookupTestType(t, "GenericTypeWithAliasConstraint").Underlying().(*types.Struct).Field(1).Type(),
+			methodName:    "Method",
+			wantHasMethod: true,
+			wantReceiver:  lookupTestType(t, "NamedInterface"),
+		},
+		{
+			name:          "TypeParamWithAliasPtr/NoMethod",
+			typ:           lookupTestType(t, "GenericTypeWithAliasConstraint").Underlying().(*types.Struct).Field(1).Type(),
+			methodName:    "NoMethod",
+			wantHasMethod: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotMethod := LookupMethod(tt.typ, tt.methodName)
+			if gotHasMethod := gotMethod != nil; gotHasMethod != tt.wantHasMethod {
+				t.Fatalf("HasMethod: got %v; want %v", gotMethod, tt.wantHasMethod)
+			}
+			if gotMethod == nil {
+				return
+			}
+			if gotMethod.Name() != tt.methodName {
+				t.Errorf("Name: got %v; want %v", gotMethod.Name(), tt.methodName)
+			}
+			if gotRecv, wantRecv := gotMethod.Signature().Recv().Type(), cmp.Or(tt.wantReceiver, tt.typ); !types.Identical(gotRecv, wantRecv) {
+				t.Errorf("Recv: got %v; want %v", gotRecv, wantRecv)
+			}
+		})
+	}
+}
+
+var namedTestTypes = sync.OnceValues(func() (map[string]types.Type, error) {
+	_, namedTypes, err := LoadTypes("test", ".")
+	return namedTypes, err
+})
+
+func lookupTestType(t *testing.T, name string) types.Type {
+	t.Helper()
+	types, err := namedTestTypes()
+	if err != nil {
+		t.Fatal(err)
+	}
+	typ, ok := types[name]
+	if !ok {
+		t.Fatalf("type %q is not declared in the current package", name)
+	}
+	return typ
+}