fix: don't see aliases as different types

This is a regression in v1.9.1 where the x/tools update preserved nested
aliases. E.g. map[string]Aliasedtype or *AliasedType. Previously, they
were automatically unaliased.

For top level types goverter already does types.Unalias but this is only
a shallow unalias.

This commit introduces a different approach to match signatures via a
custom hash map where the typehasher from
golang.org/x/tools/go/types/typeutil is used. This should ensure that
aliased types and their counterpart are seen as the same without need to
recursively unalias.

Author: jmattheis

docs/changelog.md

@@ -6,6 +6,9 @@ import GH from './GH.vue';
 
 ## unreleased
 
+- Fix comparison of signatures with aliases in
+  [`extend`](./reference/extend.md) and conversion methods. <GH issue="213" pr="215"/>
+  - This is a regression introduced in v1.9.1 due to the x/tools upgrade.
 - Upgrade toolchain to go1.25. <GH pr="214"/>
 
 ## v1.9.1

generator/generator.go

@@ -496,8 +496,8 @@ func (g *generator) shouldCreateSubMethod(ctx *builder.MethodContext, source, ta
 		// *Source -> Target
 		//  Source -> *Target
 		// *Source -> *Target
-		isCurrentPointerStructMethod = ctx.Signature.Source == source.AsPointerType().String() ||
-			ctx.Signature.Target == target.AsPointerType().String()
+		isCurrentPointerStructMethod = types.Identical(ctx.Signature.Source, source.AsPointerType()) ||
+			types.Identical(ctx.Signature.Target, target.AsPointerType())
 	}
 
 	createSubMethod := false
@@ -569,7 +569,7 @@ func (g *generator) createSubMethod(ctx *builder.MethodContext, sourceID *xtype.
 }
 
 func (g *generator) hasMethod(ctx *builder.MethodContext, source, target types.Type) bool {
-	signature := xtype.Signature{Source: source.String(), Target: target.String()}
+	signature := xtype.Signature{Source: source, Target: target}
 	return g.extend.Has(signature) || g.lookup.Has(signature)
 }
 
@@ -579,13 +579,13 @@ func (g *generator) getOverlappingStructDefinition(ctx *builder.MethodContext, s
 	}
 
 	overlapping := []xtype.Signature{
-		{Source: source.AsPointerType().String(), Target: target.String},
-		{Source: source.AsPointerType().String(), Target: target.AsPointerType().String()},
-		{Source: source.String, Target: target.AsPointerType().String()},
+		{Source: source.AsPointerType(), Target: target.T},
+		{Source: source.AsPointerType(), Target: target.AsPointerType()},
+		{Source: source.T, Target: target.AsPointerType()},
 	}
 
 	for _, sig := range overlapping {
-		if ctx.Signature == sig {
+		if ctx.Signature.Identical(sig) {
 			continue
 		}
 		if def, _ := g.lookup.Get(sig, ctx.AvailableContext); def != nil && len(def.RawFieldSettings) > 0 {

generator/validate.go

@@ -7,7 +7,7 @@ import (
 )
 
 func validateMethods(lookup *method.Index[generatedMethod]) error {
-	for _, hits := range lookup.Exact {
+	for _, hits := range lookup.Exact.Values() {
 		for _, entry := range hits {
 			genMethod := entry.Item
 

method/index.go

@@ -21,18 +21,18 @@ type IndexID struct {
 
 func NewIndex[T any]() *Index[T] {
 	return &Index[T]{
-		Exact: map[xtype.Signature][]IndexEntry[T]{},
+		Exact: xtype.NewSignatureMap[[]IndexEntry[T]](),
 	}
 }
 
 type Index[T any] struct {
-	Exact  map[xtype.Signature][]IndexEntry[T]
+	Exact  *xtype.SignatureMap[[]IndexEntry[T]]
 	Update []*T
 }
 
 func (l *Index[T]) GetAll() []*T {
 	items := []*T{}
-	for _, exacts := range l.Exact {
+	for _, exacts := range l.Exact.Values() {
 		for _, exact := range exacts {
 			items = append(items, exact.Item)
 		}
@@ -42,14 +42,17 @@ func (l *Index[T]) GetAll() []*T {
 
 func (l *Index[T]) RegisterOverrideOverlapping(t *T, def *Definition) {
 	newEntry := IndexEntry[T]{Def: def, Item: t}
-	for i, entry := range l.Exact[def.Signature] {
+	entries, _ := l.Exact.At(def.Signature)
+	for i, entry := range entries {
 		if satisfiesContext(entry.Def.Context, def.Context) || satisfiesContext(def.Context, entry.Def.Context) {
-			l.Exact[def.Signature][i] = newEntry
+			entries[i] = newEntry
+			l.Exact.Set(def.Signature, entries)
 			return
 		}
 	}
 
-	l.Exact[def.Signature] = append(l.Exact[def.Signature], newEntry)
+	entries = append(entries, newEntry)
+	l.Exact.Set(def.Signature, entries)
 }
 
 func (l *Index[T]) RegisterUpdate(t *T, def *Definition) (IndexID, error) {
@@ -58,7 +61,8 @@ func (l *Index[T]) RegisterUpdate(t *T, def *Definition) (IndexID, error) {
 }
 
 func (l *Index[T]) Register(t *T, def *Definition) (IndexID, error) {
-	for _, entry := range l.Exact[def.Signature] {
+	entries, _ := l.Exact.At(def.Signature)
+	for _, entry := range entries {
 		if err := checkOverlap(entry.Def, def); err != nil {
 			return IndexID{}, err
 		}
@@ -68,8 +72,10 @@ func (l *Index[T]) Register(t *T, def *Definition) (IndexID, error) {
 	}
 
 	newEntry := IndexEntry[T]{Def: def, Item: t}
-	l.Exact[def.Signature] = append(l.Exact[def.Signature], newEntry)
-	return IndexID{sig: def.Signature, idx: len(l.Exact[def.Signature]) - 1}, nil
+	entries = append(entries, newEntry)
+	l.Exact.Set(def.Signature, entries)
+
+	return IndexID{sig: def.Signature, idx: len(entries) - 1}, nil
 }
 
 func checkOverlap(left, right *Definition) error {
@@ -83,16 +89,17 @@ func (l *Index[T]) ByID(id IndexID) *T {
 	if id.update {
 		return l.Update[id.idx]
 	}
-	return l.Exact[id.sig][id.idx].Item
+	value, _ := l.Exact.At(id.sig)
+	return value[id.idx].Item
 }
 
 func (l *Index[T]) Has(sig xtype.Signature) bool {
-	_, ok := l.Exact[sig]
+	_, ok := l.Exact.At(sig)
 	return ok
 }
 
 func (l *Index[T]) Get(sig xtype.Signature, m map[string]*xtype.Type) (*T, error) {
-	hits, ok := l.Exact[sig]
+	hits, ok := l.Exact.At(sig)
 	if !ok {
 		return nil, nil
 	}

method/parse.go

@@ -106,7 +106,7 @@ func Parse(obj types.Object, opts *ParseOpts, localOpts LocalOpts) (*Definition,
 		case methodDef.Source == nil:
 			arg.Use = ArgUseSource
 			methodDef.Source = arg.Type
-			methodDef.Signature.Source = methodDef.Source.String
+			methodDef.Signature.Source = methodDef.Source.T
 		default:
 			arg.Use = ArgUseMultiSource
 			methodDef.MultiSources = append(methodDef.MultiSources, arg.Type)
@@ -146,7 +146,7 @@ func Parse(obj types.Object, opts *ParseOpts, localOpts LocalOpts) (*Definition,
 		return nil, formatErr("must have only one source param")
 	}
 
-	methodDef.Signature.Target = methodDef.Target.String
+	methodDef.Signature.Target = methodDef.Target.T
 
 	return methodDef, nil
 }

scenario/extend_alias.yml

@@ -0,0 +1,36 @@
+input:
+    input.go: |
+        package alias
+
+        // goverter:converter
+        // goverter:extend Conv
+        type Converter interface {
+            Convert(source Input) Output
+        }
+
+        type InputAlias = Input
+        type OutputAlias = Output
+
+        type ID = string
+
+        func Conv(i int) *string {
+            return nil
+        }
+
+        type Input struct { Name int }
+        type Output struct { Name *ID }
+success:
+    - generated/generated.go: |
+        // Code generated by github.com/jmattheis/goverter, DO NOT EDIT.
+
+        package generated
+
+        import execution "github.com/jmattheis/goverter/execution"
+
+        type ConverterImpl struct{}
+
+        func (c *ConverterImpl) Convert(source execution.Input) execution.Output {
+        	var aliasOutput execution.Output
+        	aliasOutput.Name = execution.Conv(source.Name)
+        	return aliasOutput
+        }

xtype/map.go

@@ -0,0 +1,70 @@
+package xtype
+
+import (
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+func NewSignatureMap[T any]() *SignatureMap[T] {
+	return &SignatureMap[T]{
+		table: map[hashedSignature][]entry[T]{},
+	}
+}
+
+// Implements a hash map with a Signature key. Uses the hash of types.Type via typeutil.
+type SignatureMap[T any] struct {
+	table map[hashedSignature][]entry[T]
+}
+
+type entry[T any] struct {
+	key   Signature
+	value T
+}
+
+type hashedSignature struct {
+	source uint32
+	target uint32
+}
+
+func (m *SignatureMap[T]) At(key Signature) (T, bool) {
+	for _, entry := range m.table[hash(key)] {
+		if key.Identical(entry.key) {
+			return entry.value, true
+		}
+	}
+	var empty T
+	return empty, false
+}
+
+func (m *SignatureMap[T]) Set(key Signature, value T) {
+	hashed := hash(key)
+	bucket := m.table[hashed]
+	for i, entry := range bucket {
+		if key.Identical(entry.key) {
+			bucket[i].value = value
+			return
+		}
+	}
+
+	m.table[hashed] = append(bucket, entry[T]{key: key, value: value})
+}
+
+func (m *SignatureMap[T]) Values() []T {
+	values := make([]T, 0, len(m.table))
+
+	for _, bucket := range m.table {
+		for _, entry := range bucket {
+			values = append(values, entry.value)
+		}
+	}
+
+	return values
+}
+
+func hash(t Signature) hashedSignature {
+	return hashedSignature{
+		source: theHasher.Hash(t.Source),
+		target: theHasher.Hash(t.Target),
+	}
+}
+
+var theHasher typeutil.Hasher

xtype/type.go

@@ -13,12 +13,16 @@ const ThisVar = "c"
 
 // Signature represents a signature for conversion.
 type Signature struct {
-	Source string
-	Target string
+	Source types.Type
+	Target types.Type
+}
+
+func (s *Signature) Identical(other Signature) bool {
+	return types.Identical(s.Source, other.Source) && types.Identical(s.Target, other.Target)
 }
 
 func SignatureOf(source, target *Type) Signature {
-	return Signature{Source: source.String, Target: target.String}
+	return Signature{Source: source.T, Target: target.T}
 }
 
 // Type is a helper wrapper for types.Type.