Go 1.23 support

.github/workflows/coverage.yml

@@ -16,7 +16,7 @@ jobs:
   coverage:
     strategy:
       matrix:
-        go: ["1.22"]
+        go: ["1.23"]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

.github/workflows/fmt-and-generate.yml

@@ -16,7 +16,7 @@ jobs:
   fmt-and-lint:
     strategy:
       matrix:
-        go: ["1.21", "1.22"]
+        go: ["1.22", "1.23"]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

.github/workflows/integration.yml

@@ -16,7 +16,7 @@ jobs:
   integration:
     strategy:
       matrix:
-        go: ["1.21", "1.22"]
+        go: ["1.22", "1.23"]
         node: [18]
     runs-on: ubuntu-latest
     timeout-minutes: 3
@@ -35,7 +35,7 @@ jobs:
   federation:
     strategy:
       matrix:
-        go: ["1.21", "1.22"]
+        go: ["1.22", "1.23"]
         node: [18]
     runs-on: ubuntu-latest
     steps:
@@ -53,7 +53,7 @@ jobs:
   init:
     strategy:
       matrix:
-        go: ["1.21", "1.22"]
+        go: ["1.22", "1.23"]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

.github/workflows/lint.yml

@@ -15,10 +15,10 @@ concurrency:
 jobs:
   golangci-lint:
     env:
-      GOLANGCI_LINT_VERSION: v1.59.1
+      GOLANGCI_LINT_VERSION: v1.60.2
     strategy:
       matrix:
-        go: ["1.21", "1.22"]
+        go: ["1.22", "1.23"]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

.github/workflows/test.yml

@@ -24,7 +24,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest]
-        go: ["1.21", "1.22"]
+        go: ["1.22", "1.23"]
     runs-on: ${{ matrix.os }}
     continue-on-error: true
     steps:

.golangci.yml

@@ -113,3 +113,11 @@ issues:
       text: "use-any: since GO 1.18 'interface{}' can be replaced by 'any'"
     - path: codegen/testserver/singlefile/resolver.go
       text: "use-any: since GO 1.18 'interface{}' can be replaced by 'any'"
+    - path: codegen/testserver/generated_test.go
+      linters:
+        - staticcheck
+      text: SA1019
+    - path: plugin/modelgen/models_test.go
+      linters:
+        - staticcheck
+      text: SA1019

codegen/field.go

@@ -6,7 +6,6 @@ import (
 	goast "go/ast"
 	"go/types"
 	"log"
-	"reflect"
 	"strconv"
 	"strings"
 
@@ -144,7 +143,7 @@ func (b *builder) bindField(obj *Object, f *Field) (errret error) {
 		f.GoFieldName = b.Config.Models[obj.Name].Fields[f.Name].FieldName
 	}
 
-	target, err := b.findBindTarget(obj.Type.(*types.Named), f.GoFieldName)
+	target, err := b.findBindTarget(obj.Type, f.GoFieldName)
 	if err != nil {
 		return err
 	}
@@ -269,53 +268,6 @@ func (b *builder) findBindTarget(t types.Type, name string) (types.Object, error
 	return b.findBindEmbedsTarget(t, name)
 }
 
-func (b *builder) findBindStructTagTarget(in types.Type, name string) (types.Object, error) {
-	if b.Config.StructTag == "" {
-		return nil, nil
-	}
-
-	switch t := in.(type) {
-	case *types.Named:
-		return b.findBindStructTagTarget(t.Underlying(), name)
-	case *types.Struct:
-		var found types.Object
-		for i := 0; i < t.NumFields(); i++ {
-			field := t.Field(i)
-			if !field.Exported() || field.Embedded() {
-				continue
-			}
-			tags := reflect.StructTag(t.Tag(i))
-			if val, ok := tags.Lookup(b.Config.StructTag); ok && equalFieldName(val, name) {
-				if found != nil {
-					return nil, fmt.Errorf("tag %s is ambiguous; multiple fields have the same tag value of %s", b.Config.StructTag, val)
-				}
-
-				found = field
-			}
-		}
-
-		return found, nil
-	}
-
-	return nil, nil
-}
-
-func (b *builder) findBindMethodTarget(in types.Type, name string) (types.Object, error) {
-	switch t := in.(type) {
-	case *types.Named:
-		if _, ok := t.Underlying().(*types.Interface); ok {
-			return b.findBindMethodTarget(t.Underlying(), name)
-		}
-
-		return b.findBindMethoderTarget(t.Method, t.NumMethods(), name)
-	case *types.Interface:
-		// FIX-ME: Should use ExplicitMethod here? What's the difference?
-		return b.findBindMethoderTarget(t.Method, t.NumMethods(), name)
-	}
-
-	return nil, nil
-}
-
 func (b *builder) findBindMethoderTarget(methodFunc func(i int) *types.Func, methodCount int, name string) (types.Object, error) {
 	var found types.Object
 	for i := 0; i < methodCount; i++ {
@@ -334,44 +286,6 @@ func (b *builder) findBindMethoderTarget(methodFunc func(i int) *types.Func, met
 	return found, nil
 }
 
-func (b *builder) findBindFieldTarget(in types.Type, name string) (types.Object, error) {
-	switch t := in.(type) {
-	case *types.Named:
-		return b.findBindFieldTarget(t.Underlying(), name)
-	case *types.Struct:
-		var found types.Object
-		for i := 0; i < t.NumFields(); i++ {
-			field := t.Field(i)
-			if !field.Exported() || !equalFieldName(field.Name(), name) {
-				continue
-			}
-
-			if found != nil {
-				return nil, fmt.Errorf("found more than one matching field to bind for %s", name)
-			}
-
-			found = field
-		}
-
-		return found, nil
-	}
-
-	return nil, nil
-}
-
-func (b *builder) findBindEmbedsTarget(in types.Type, name string) (types.Object, error) {
-	switch t := in.(type) {
-	case *types.Named:
-		return b.findBindEmbedsTarget(t.Underlying(), name)
-	case *types.Struct:
-		return b.findBindStructEmbedsTarget(t, name)
-	case *types.Interface:
-		return b.findBindInterfaceEmbedsTarget(t, name)
-	}
-
-	return nil, nil
-}
-
 func (b *builder) findBindStructEmbedsTarget(strukt *types.Struct, name string) (types.Object, error) {
 	var found types.Object
 	for i := 0; i < strukt.NumFields(); i++ {

codegen/field_1.23.go

@@ -0,0 +1,102 @@
+//go:build go1.23
+
+package codegen
+
+import (
+	"fmt"
+	"go/types"
+	"reflect"
+)
+
+func (b *builder) findBindFieldTarget(in types.Type, name string) (types.Object, error) {
+	switch t := in.(type) {
+	case *types.Alias:
+		return b.findBindFieldTarget(t.Rhs(), name)
+	case *types.Named:
+		return b.findBindFieldTarget(t.Underlying(), name)
+	case *types.Struct:
+		var found types.Object
+		for i := 0; i < t.NumFields(); i++ {
+			field := t.Field(i)
+			if !field.Exported() || !equalFieldName(field.Name(), name) {
+				continue
+			}
+
+			if found != nil {
+				return nil, fmt.Errorf("found more than one matching field to bind for %s", name)
+			}
+
+			found = field
+		}
+
+		return found, nil
+	}
+
+	return nil, nil
+}
+
+func (b *builder) findBindEmbedsTarget(in types.Type, name string) (types.Object, error) {
+	switch t := in.(type) {
+	case *types.Alias:
+		return b.findBindEmbedsTarget(t.Rhs(), name)
+	case *types.Named:
+		return b.findBindEmbedsTarget(t.Underlying(), name)
+	case *types.Struct:
+		return b.findBindStructEmbedsTarget(t, name)
+	case *types.Interface:
+		return b.findBindInterfaceEmbedsTarget(t, name)
+	}
+
+	return nil, nil
+}
+
+func (b *builder) findBindStructTagTarget(in types.Type, name string) (types.Object, error) {
+	if b.Config.StructTag == "" {
+		return nil, nil
+	}
+
+	switch t := in.(type) {
+	case *types.Alias:
+		return b.findBindStructTagTarget(t.Rhs(), name)
+	case *types.Named:
+		return b.findBindStructTagTarget(t.Underlying(), name)
+	case *types.Struct:
+		var found types.Object
+		for i := 0; i < t.NumFields(); i++ {
+			field := t.Field(i)
+			if !field.Exported() || field.Embedded() {
+				continue
+			}
+			tags := reflect.StructTag(t.Tag(i))
+			if val, ok := tags.Lookup(b.Config.StructTag); ok && equalFieldName(val, name) {
+				if found != nil {
+					return nil, fmt.Errorf("tag %s is ambiguous; multiple fields have the same tag value of %s", b.Config.StructTag, val)
+				}
+
+				found = field
+			}
+		}
+
+		return found, nil
+	}
+
+	return nil, nil
+}
+
+func (b *builder) findBindMethodTarget(in types.Type, name string) (types.Object, error) {
+	switch t := in.(type) {
+	case *types.Alias:
+		return b.findBindMethodTarget(t.Rhs(), name)
+	case *types.Named:
+		if _, ok := t.Underlying().(*types.Interface); ok {
+			return b.findBindMethodTarget(t.Underlying(), name)
+		}
+
+		return b.findBindMethoderTarget(t.Method, t.NumMethods(), name)
+	case *types.Interface:
+		// FIX-ME: Should use ExplicitMethod here? What's the difference?
+		return b.findBindMethoderTarget(t.Method, t.NumMethods(), name)
+	}
+
+	return nil, nil
+}

codegen/field_other.go

@@ -0,0 +1,94 @@
+//go:build !go1.23
+
+package codegen
+
+import (
+	"fmt"
+	"go/types"
+	"reflect"
+)
+
+func (b *builder) findBindFieldTarget(in types.Type, name string) (types.Object, error) {
+	switch t := in.(type) {
+	case *types.Named:
+		return b.findBindFieldTarget(t.Underlying(), name)
+	case *types.Struct:
+		var found types.Object
+		for i := 0; i < t.NumFields(); i++ {
+			field := t.Field(i)
+			if !field.Exported() || !equalFieldName(field.Name(), name) {
+				continue
+			}
+
+			if found != nil {
+				return nil, fmt.Errorf("found more than one matching field to bind for %s", name)
+			}
+
+			found = field
+		}
+
+		return found, nil
+	}
+
+	return nil, nil
+}
+
+func (b *builder) findBindEmbedsTarget(in types.Type, name string) (types.Object, error) {
+	switch t := in.(type) {
+	case *types.Named:
+		return b.findBindEmbedsTarget(t.Underlying(), name)
+	case *types.Struct:
+		return b.findBindStructEmbedsTarget(t, name)
+	case *types.Interface:
+		return b.findBindInterfaceEmbedsTarget(t, name)
+	}
+
+	return nil, nil
+}
+
+func (b *builder) findBindStructTagTarget(in types.Type, name string) (types.Object, error) {
+	if b.Config.StructTag == "" {
+		return nil, nil
+	}
+
+	switch t := in.(type) {
+	case *types.Named:
+		return b.findBindStructTagTarget(t.Underlying(), name)
+	case *types.Struct:
+		var found types.Object
+		for i := 0; i < t.NumFields(); i++ {
+			field := t.Field(i)
+			if !field.Exported() || field.Embedded() {
+				continue
+			}
+			tags := reflect.StructTag(t.Tag(i))
+			if val, ok := tags.Lookup(b.Config.StructTag); ok && equalFieldName(val, name) {
+				if found != nil {
+					return nil, fmt.Errorf("tag %s is ambiguous; multiple fields have the same tag value of %s", b.Config.StructTag, val)
+				}
+
+				found = field
+			}
+		}
+
+		return found, nil
+	}
+
+	return nil, nil
+}
+
+func (b *builder) findBindMethodTarget(in types.Type, name string) (types.Object, error) {
+	switch t := in.(type) {
+	case *types.Named:
+		if _, ok := t.Underlying().(*types.Interface); ok {
+			return b.findBindMethodTarget(t.Underlying(), name)
+		}
+
+		return b.findBindMethoderTarget(t.Method, t.NumMethods(), name)
+	case *types.Interface:
+		// FIX-ME: Should use ExplicitMethod here? What's the difference?
+		return b.findBindMethoderTarget(t.Method, t.NumMethods(), name)
+	}
+
+	return nil, nil
+}