feat(injector/typed): Enhance type checking with additional generic type test cases (#634)

Comprehensive tests have been added to validate these changes, ensuring
that the type checker functions correctly across a wide range of generic
type scenarios.

Signed-off-by: Kemal Akkoyun <[email protected]>

Signed-off-by: Kemal Akkoyun <[email protected]>

Author: kakkoyun

internal/injector/typed/typecheck.go

@@ -83,12 +83,31 @@ func ResolveInterfaceTypeByName(name string) (*types.Interface, error) {
 // into its package path and local name.
 // Returns ("", "error") for built-in "error".
 // Returns ("", "MyType") for unqualified "MyType".
+// For generic types like "iter.Seq[T]" or "iter.Seq[io.Reader]", the type parameters
+// are included in the local name, so it returns ("iter", "Seq[T]") and ("iter", "Seq[io.Reader]").
 func SplitPackageAndName(fullName string) (pkgPath string, localName string) {
 	if !strings.Contains(fullName, ".") {
 		// Assume built-in type (like "error") or unqualified local type.
 		return "", fullName
 	}
-	lastDot := strings.LastIndex(fullName, ".")
+
+	// Find the position of the first '[' which indicates generic type parameters
+	bracketPos := strings.IndexByte(fullName, '[')
+
+	// Determine the substring to search for the last dot
+	searchStr := fullName
+	if bracketPos != -1 {
+		// Only search for dots before the generic type parameters
+		searchStr = fullName[:bracketPos]
+	}
+
+	// Find the last dot in the search string
+	lastDot := strings.LastIndex(searchStr, ".")
+	if lastDot == -1 {
+		// No dot found (shouldn't happen given the initial check, but be safe)
+		return "", fullName
+	}
+
 	pkgPath = fullName[:lastDot]
 	localName = fullName[lastDot+1:]
 	return pkgPath, localName

internal/injector/typed/typecheck_test.go

@@ -129,6 +129,79 @@ func TestSplitPackageAndName(t *testing.T) {
 			expectedPkg:   "k8s.io/client-go/kubernetes",
 			expectedLocal: "Clientset",
 		},
+		// Generic type test cases
+		{
+			name:          "simple generic type",
+			fullName:      "iter.Seq[T]",
+			expectedPkg:   "iter",
+			expectedLocal: "Seq[T]",
+		},
+		{
+			name:          "generic with qualified type parameter",
+			fullName:      "iter.Seq[io.Reader]",
+			expectedPkg:   "iter",
+			expectedLocal: "Seq[io.Reader]",
+		},
+		{
+			name:          "generic with multiple type parameters",
+			fullName:      "maps.Map[string, int]",
+			expectedPkg:   "maps",
+			expectedLocal: "Map[string, int]",
+		},
+		{
+			name:          "nested generic types",
+			fullName:      "container.List[maps.Map[string, io.Reader]]",
+			expectedPkg:   "container",
+			expectedLocal: "List[maps.Map[string, io.Reader]]",
+		},
+		{
+			name:          "generic with slice type parameter",
+			fullName:      "sync.Pool[[]byte]",
+			expectedPkg:   "sync",
+			expectedLocal: "Pool[[]byte]",
+		},
+		{
+			name:          "generic with pointer type parameter",
+			fullName:      "atomic.Pointer[*sync.Mutex]",
+			expectedPkg:   "atomic",
+			expectedLocal: "Pointer[*sync.Mutex]",
+		},
+		{
+			name:          "generic from versioned package",
+			fullName:      "github.com/user/pkg/v2.Container[T]",
+			expectedPkg:   "github.com/user/pkg/v2",
+			expectedLocal: "Container[T]",
+		},
+		{
+			name:          "complex generic with multiple qualified parameters",
+			fullName:      "github.com/example/collections.Map[database/sql.DB, net/http.Client]",
+			expectedPkg:   "github.com/example/collections",
+			expectedLocal: "Map[database/sql.DB, net/http.Client]",
+		},
+		{
+			name:          "generic with map type parameter",
+			fullName:      "container.Set[map[string]interface{}]",
+			expectedPkg:   "container",
+			expectedLocal: "Set[map[string]interface{}]",
+		},
+		{
+			name:          "generic with channel type parameter",
+			fullName:      "async.Queue[chan error]",
+			expectedPkg:   "async",
+			expectedLocal: "Queue[chan error]",
+		},
+		{
+			name:          "unqualified generic type",
+			fullName:      "MyGeneric[T]",
+			expectedPkg:   "",
+			expectedLocal: "MyGeneric[T]",
+		},
+		{
+			name:          "generic with function type parameter",
+			fullName:      "functional.Option[func(io.Writer) error]",
+			expectedPkg:   "functional",
+			expectedLocal: "Option[func(io.Writer) error]",
+		},
 	}
 
 	for _, tc := range testCases {