Merge pull request #1463 from shilei365/fix/generic-typealias-parameter-substitution

Fix: substitute generic type parameters when resolving typealiases

Author: krzysztofzablocki

SourceryRuntime/Sources/Common/Composer/ParserResultsComposed.swift

@@ -661,6 +661,70 @@ internal struct ParserResultsComposed {
         let set = typeName.set.map { SetType(name: $0.name, elementTypeName: $0.elementTypeName, elementType: $0.elementType) }
         set?.name = aliased.name
 
+        // When the typealias is generic (e.g. `typealias Foo<T> = Bar<T, Never>`),
+        // substitute the typealias definition's generic placeholders with the
+        // concrete type arguments from the usage site.
+        let resolvedGeneric: GenericType?
+        if let aliasTypealias = aliased.typealias,
+           let aliasGeneric = aliasTypealias.typeName.generic,
+           let usageSiteGeneric = typeName.generic {
+            // Build a mapping from the typealias's placeholder names to the
+            // concrete types at the usage site.
+            // e.g. typealias CurrentValuePublisher<Value> = AnyPublisher<Value, Never>
+            //      usage: CurrentValuePublisher<[MyDataModel]?>
+            //      → mapping: ["Value": "[MyDataModel]?"]
+            //
+            // The alias name (e.g. "CurrentValuePublisher") has the same number
+            // of generic parameters as the usage site. To find the placeholder
+            // names we look at the alias definition's *own* generic parameter
+            // list.  Sourcery stores the alias `typeName` as the RHS
+            // (e.g. `AnyPublisher<Value, Never>`), so the placeholder names
+            // appear as type-parameter names in the RHS that match the LHS
+            // parameter names.  Since Sourcery does not store the LHS generic
+            // parameter list on `Typealias`, we infer them: any type-parameter
+            // in the RHS generic that is NOT a known type is a placeholder.
+            //
+            // A simpler and more reliable heuristic: pair up the usage-site
+            // parameters with the alias name's parameters positionally —
+            // both have the same arity.
+            var placeholderMapping = [String: TypeName]()
+            for (index, usageParam) in usageSiteGeneric.typeParameters.enumerated() {
+                // The placeholder name at this position is inferred from the
+                // alias RHS by checking which RHS parameters are *not* concrete
+                // types.  However the most robust approach is to note that the
+                // LHS generic parameter at position `index` corresponds to the
+                // usage-site parameter at the same position.
+                //
+                // We scan the RHS generic for parameters whose typeName matches
+                // no known type and build the mapping.
+                // For safety, just iterate and map positionally if within bounds.
+                if index < aliasGeneric.typeParameters.count {
+                    let rhsParam = aliasGeneric.typeParameters[index]
+                    let rhsName = rhsParam.typeName.unwrappedTypeName
+                    // Check if this RHS parameter is a placeholder (not a known type)
+                    if typeMap[rhsName] == nil && resolvedTypealiases[rhsName] == nil {
+                        placeholderMapping[rhsName] = usageParam.typeName
+                    }
+                }
+            }
+
+            if !placeholderMapping.isEmpty {
+                // Substitute placeholders in the RHS generic type parameters
+                let substitutedParams = aliasGeneric.typeParameters.map { param -> GenericTypeParameter in
+                    let paramName = param.typeName.unwrappedTypeName
+                    if let concreteTypeName = placeholderMapping[paramName] {
+                        return GenericTypeParameter(typeName: concreteTypeName, type: param.type)
+                    }
+                    return param
+                }
+                resolvedGeneric = GenericType(name: aliasGeneric.name, typeParameters: substitutedParams)
+            } else {
+                resolvedGeneric = aliasGeneric
+            }
+        } else {
+            resolvedGeneric = aliased.typealias?.typeName.generic ?? generic
+        }
+
         return TypeName(name: aliased.name,
                         isOptional: typeName.isOptional,
                         isImplicitlyUnwrappedOptional: typeName.isImplicitlyUnwrappedOptional,
@@ -669,7 +733,7 @@ internal struct ParserResultsComposed {
                         dictionary: aliased.typealias?.typeName.dictionary ?? dictionary,
                         closure: aliased.typealias?.typeName.closure ?? typeName.closure,
                         set: aliased.typealias?.typeName.set ?? set,
-                        generic: aliased.typealias?.typeName.generic ?? generic
+                        generic: resolvedGeneric
         )
     }
 

SourceryTests/Parsing/ComposerSpec.swift

@@ -1407,6 +1407,68 @@ class ParserComposerSpec: QuickSpec {
                         }
                     }
 
+                    context("given generic typealias") {
+                        it("substitutes placeholder type parameters with concrete types from usage site") {
+                            let code = """
+                                       typealias MyPublisher<Value> = Result<Value, Never>
+                                       protocol DataPublishing {
+                                           var itemsPublisher: MyPublisher<[String]?> { get }
+                                       }
+                                       """
+                            let types = parse(code)
+                            let proto = types.first(where: { $0.name == "DataPublishing" })
+                            let variable = proto?.variables.first
+
+                            // actualTypeName should resolve to Result<[String]?, Never>
+                            let actualGeneric = variable?.typeName.actualTypeName?.generic
+                            expect(actualGeneric?.name).to(equal("Result"))
+                            expect(actualGeneric?.typeParameters).to(haveCount(2))
+                            // First type parameter should be the concrete type from usage site, not the placeholder "Value"
+                            expect(actualGeneric?.typeParameters.first?.typeName.name).to(equal("[String]?"))
+                            // Second type parameter should remain "Never" (it's a concrete type in the typealias RHS)
+                            expect(actualGeneric?.typeParameters.last?.typeName.name).to(equal("Never"))
+                        }
+
+                        it("substitutes multiple placeholder type parameters with concrete types") {
+                            let code = """
+                                       typealias MyResult<Success, Failure> = Result<Success, Failure>
+                                       protocol Service {
+                                           var result: MyResult<String, Error> { get }
+                                       }
+                                       """
+                            let types = parse(code)
+                            let proto = types.first(where: { $0.name == "Service" })
+                            let variable = proto?.variables.first
+
+                            let actualGeneric = variable?.typeName.actualTypeName?.generic
+                            expect(actualGeneric?.name).to(equal("Result"))
+                            expect(actualGeneric?.typeParameters).to(haveCount(2))
+                            expect(actualGeneric?.typeParameters.first?.typeName.name).to(equal("String"))
+                            expect(actualGeneric?.typeParameters.last?.typeName.name).to(equal("Error"))
+                        }
+
+                        it("does not substitute concrete types that exist in the type map") {
+                            let code = """
+                                       struct Never {}
+                                       typealias MyPublisher<Value> = Result<Value, Never>
+                                       protocol Publishing {
+                                           var publisher: MyPublisher<Int> { get }
+                                       }
+                                       """
+                            let types = parse(code)
+                            let proto = types.first(where: { $0.name == "Publishing" })
+                            let variable = proto?.variables.first
+
+                            let actualGeneric = variable?.typeName.actualTypeName?.generic
+                            expect(actualGeneric?.name).to(equal("Result"))
+                            expect(actualGeneric?.typeParameters).to(haveCount(2))
+                            // "Value" placeholder should be substituted with "Int"
+                            expect(actualGeneric?.typeParameters.first?.typeName.name).to(equal("Int"))
+                            // "Never" is a known type, should NOT be substituted
+                            expect(actualGeneric?.typeParameters.last?.typeName.name).to(equal("Never"))
+                        }
+                    }
+
                     context("given method parameter") {
                         it("replaces method parameter type alias with actual type") {
                             let expectedMethodParameter = MethodParameter(name: "foo", index: 0, typeName: TypeName(name: "FooAlias", actualTypeName: TypeName(name: "Foo")), type: Class(name: "Foo"))