Update Swift Syntax to 602.0.0

Package.swift

@@ -25,15 +25,15 @@ let package = Package(
     dependencies: [
         .package(
             url: "https://github.com/fetch-rewards/swift-locking.git",
-            exact: "0.2.0"
+            exact: "0.2.1"
         ),
         .package(
             url: "https://github.com/swiftlang/swift-syntax.git",
-            exact: "600.0.0" // Must match SwiftSyntaxSugar's swift-syntax version
+            from: "602.0.0" // Must match SwiftSyntaxSugar's swift-syntax version
         ),
         .package(
             url: "https://github.com/fetch-rewards/SwiftSyntaxSugar.git",
-            exact: "0.1.1" // Must match swift-locking's SwiftSyntaxSugar version
+            from: "0.1.2" // Must match swift-locking's SwiftSyntaxSugar version
         ),
     ],
     targets: [

Sources/MockingClient/GenericMethodsWithInlineArrayTypes.swift

@@ -0,0 +1,30 @@
+//
+//  GenericMethodsWithInlineArrayTypes.swift
+//
+//  Copyright © 2025 Fetch.
+//
+
+import Foundation
+public import Mocking
+
+/// A protocol for verifying Mocked's handling of generic methods that leverage
+/// inline array syntax and value-generic arguments.
+///
+/// - Important: Please only use this protocol for permanent verification of
+///   Mocked's handling of inline array syntax. For temporary testing of Mocked's
+///   expansion, use the `Playground` protocol in `main.swift`.
+@available(macOS 26.0, *)
+@Mocked
+public protocol GenericMethodsWithInlineArrayTypes {
+    func genericMethodWithInlineArrayParameter<Element>(
+        parameter: [3 of Element]
+    ) -> [3 of Element]
+
+    func genericMethodReturningInlineArray<Element>(
+        parameter: InlineArray<3, Element>
+    ) -> InlineArray<3, Element>
+
+    func genericMethodWithInlineArraySameTypeRequirement<Element>(
+        parameter: InlineArray<3, Element>
+    ) -> Element where Element: Sendable, InlineArray<3, Element> == InlineArray<3, Element>
+}

Sources/MockingMacros/Macros/MockedMethodMacro/MockedMethodMacro+TypeErasure.swift

@@ -247,6 +247,15 @@ extension MockedMethodMacro {
                 ifTypeIsContainedIn: genericParameters,
                 typeConstrainedBy: genericWhereClause
             )
+        case var .inlineArrayType(type):
+            let (element, didTypeEraseElement) = self.syntax(
+                type.element,
+                ifTypeIsContainedIn: genericParameters,
+                typeConstrainedBy: genericWhereClause
+            )
+
+            type = type.with(\.element, element)
+            result = (newType: type, didTypeErase: didTypeEraseElement)
         case let .tupleType(type):
             result = self.syntax(
                 type,
@@ -456,9 +465,7 @@ extension MockedMethodMacro {
         ):
             let (newGenericArgumentClause, didTypeErase) = self.syntax(
                 genericArgumentClause,
-                withElementsInCollectionAt: \.arguments,
-                typeErasedAt: \.argument,
-                ifTypeIsContainedIn: genericParameters,
+                typeErasedIfElementsIn: genericParameters,
                 typeConstrainedBy: genericWhereClause
             )
             let newType = type.with(\.genericArgumentClause, newGenericArgumentClause)
@@ -470,15 +477,25 @@ extension MockedMethodMacro {
         ):
             let (newGenericArgumentClause, didTypeErase) = self.syntax(
                 genericArgumentClause,
-                withElementsInCollectionAt: \.arguments,
-                typeErasedAt: \.argument,
-                ifTypeIsContainedIn: genericParameters,
+                typeErasedIfElementsIn: genericParameters,
                 typeConstrainedBy: genericWhereClause
             ) { index in
                 index == .zero ? AnyHashable.self : Any.self
             }
             let newType = type.with(\.genericArgumentClause, newGenericArgumentClause)
 
+            return (newType, didTypeErase)
+        case let .identifierType(type) where self.isIdentifierType(
+            type,
+            named: "InlineArray"
+        ):
+            let (newGenericArgumentClause, didTypeErase) = self.inlineArrayGenericArgumentClause(
+                genericArgumentClause,
+                typeErasingElementsIn: genericParameters,
+                typeConstrainedBy: genericWhereClause
+            )
+            let newType = type.with(\.genericArgumentClause, newGenericArgumentClause)
+
             return (newType, didTypeErase)
         case let .memberType(type) where self.isMemberType(
             type,
@@ -487,9 +504,7 @@ extension MockedMethodMacro {
         ):
             let (newGenericArgumentClause, didTypeErase) = self.syntax(
                 genericArgumentClause,
-                withElementsInCollectionAt: \.arguments,
-                typeErasedAt: \.argument,
-                ifTypeIsContainedIn: genericParameters,
+                typeErasedIfElementsIn: genericParameters,
                 typeConstrainedBy: genericWhereClause
             )
             let newType = type.with(\.genericArgumentClause, newGenericArgumentClause)
@@ -502,22 +517,31 @@ extension MockedMethodMacro {
         ):
             let (newGenericArgumentClause, didTypeErase) = self.syntax(
                 genericArgumentClause,
-                withElementsInCollectionAt: \.arguments,
-                typeErasedAt: \.argument,
-                ifTypeIsContainedIn: genericParameters,
+                typeErasedIfElementsIn: genericParameters,
                 typeConstrainedBy: genericWhereClause
             ) { index in
                 index == .zero ? AnyHashable.self : Any.self
             }
             let newType = type.with(\.genericArgumentClause, newGenericArgumentClause)
 
+            return (newType, didTypeErase)
+        case let .memberType(type) where self.isMemberType(
+            type,
+            named: "InlineArray",
+            withBaseTypeNamed: "Swift"
+        ):
+            let (newGenericArgumentClause, didTypeErase) = self.inlineArrayGenericArgumentClause(
+                genericArgumentClause,
+                typeErasingElementsIn: genericParameters,
+                typeConstrainedBy: genericWhereClause
+            )
+            let newType = type.with(\.genericArgumentClause, newGenericArgumentClause)
+
             return (newType, didTypeErase)
         default:
             let (_, didTypeErase) = self.syntax(
                 genericArgumentClause,
-                withElementsInCollectionAt: \.arguments,
-                typeErasedAt: \.argument,
-                ifTypeIsContainedIn: genericParameters,
+                typeErasedIfElementsIn: genericParameters,
                 typeConstrainedBy: genericWhereClause
             )
 
@@ -531,6 +555,108 @@ extension MockedMethodMacro {
         }
     }
 
+    private static func syntax(
+        _ argument: GenericArgumentSyntax,
+        ifTypeIsContainedIn genericParameters: GenericParameterListSyntax?,
+        typeConstrainedBy genericWhereClause: GenericWhereClauseSyntax?,
+        typeErasedType: (some Any).Type = Any.self
+    ) -> (GenericArgumentSyntax, Bool) {
+        guard case let .type(type) = argument.argument else {
+            return (argument, false)
+        }
+
+        let (erasedType, didTypeErase) = self.type(
+            type,
+            typeErasedIfNecessaryUsing: genericParameters,
+            typeConstrainedBy: genericWhereClause,
+            typeErasedType: typeErasedType
+        )
+
+        let newArgument = argument.with(
+            \.argument,
+            .type(TypeSyntax(erasedType))
+        )
+
+        return (newArgument, didTypeErase)
+    }
+
+    private static func syntax(
+        _ clause: GenericArgumentClauseSyntax,
+        typeErasedIfElementsIn genericParameters: GenericParameterListSyntax?,
+        typeConstrainedBy genericWhereClause: GenericWhereClauseSyntax?,
+        typeErasedType: (Int) -> Any.Type
+    ) -> (GenericArgumentClauseSyntax, Bool) {
+        var didTypeErase = false
+        var newArguments: [GenericArgumentSyntax] = []
+
+        for (index, argument) in clause.arguments.enumerated() {
+            let (newArgument, didTypeEraseArgument) = self.syntax(
+                argument,
+                ifTypeIsContainedIn: genericParameters,
+                typeConstrainedBy: genericWhereClause,
+                typeErasedType: typeErasedType(index)
+            )
+
+            newArguments.append(newArgument)
+            didTypeErase = didTypeErase || didTypeEraseArgument
+        }
+
+        let newClause = clause.with(
+            \.arguments,
+            GenericArgumentListSyntax(newArguments)
+        )
+
+        return (newClause, didTypeErase)
+    }
+
+    private static func syntax(
+        _ clause: GenericArgumentClauseSyntax,
+        typeErasedIfElementsIn genericParameters: GenericParameterListSyntax?,
+        typeConstrainedBy genericWhereClause: GenericWhereClauseSyntax?
+    ) -> (GenericArgumentClauseSyntax, Bool) {
+        self.syntax(
+            clause,
+            typeErasedIfElementsIn: genericParameters,
+            typeConstrainedBy: genericWhereClause
+        ) { _ in Any.self }
+    }
+
+    private static func inlineArrayGenericArgumentClause(
+        _ clause: GenericArgumentClauseSyntax,
+        typeErasingElementsIn genericParameters: GenericParameterListSyntax?,
+        typeConstrainedBy genericWhereClause: GenericWhereClauseSyntax?
+    ) -> (GenericArgumentClauseSyntax, Bool) {
+        guard !clause.arguments.isEmpty else {
+            return (clause, false)
+        }
+
+        var didTypeErase = false
+        var newArguments: [GenericArgumentSyntax] = []
+
+        for (index, argument) in clause.arguments.enumerated() {
+            if index == .zero {
+                newArguments.append(argument)
+                continue
+            }
+
+            let (newArgument, didTypeEraseArgument) = self.syntax(
+                argument,
+                ifTypeIsContainedIn: genericParameters,
+                typeConstrainedBy: genericWhereClause
+            )
+
+            newArguments.append(newArgument)
+            didTypeErase = didTypeErase || didTypeEraseArgument
+        }
+
+        let newClause = clause.with(
+            \.arguments,
+            GenericArgumentListSyntax(newArguments)
+        )
+
+        return (newClause, didTypeErase)
+    }
+
     /// Returns a Boolean value indicating whether the provided identifier
     /// type's name matches any of the provided `names`.
     ///