fix: swift 5.9+ version compile error

Author: ElonPark

Sources/KarrotListKitMacros/AddComponentModifierMacro.swift

@@ -9,13 +9,21 @@ import SwiftSyntaxMacros
 
 public struct AddComponentModifierMacro: PeerMacro {
   public static func expansion(
-    of _: SwiftSyntax.AttributeSyntax,
+    of node: AttributeSyntax,
     providingPeersOf declaration: some DeclSyntaxProtocol,
     in context: some MacroExpansionContext
   ) throws -> [DeclSyntax] {
+    var lexicalContext: [Syntax] {
+      #if canImport(SwiftSyntax600)
+      context.lexicalContext
+      #else
+      declaration.allMacroLexicalContexts()
+      #endif
+    }
+
     // struct 선언인지 확인
     guard
-      let structDecl = context.lexicalContext.compactMap({ $0.as(StructDeclSyntax.self) }).first
+      let structDecl = lexicalContext.compactMap({ $0.as(StructDeclSyntax.self) }).first
     else {
       throw KarrotListKitMacroError(message: "@AddComponentModifier can only be applied to structs")
     }
@@ -100,3 +108,87 @@ public struct AddComponentModifierMacro: PeerMacro {
     return structAccessLevel.name.text + " "
   }
 }
+
+#if !canImport(SwiftSyntax600)
+extension SyntaxProtocol {
+  /// If this syntax node acts as a lexical context from the perspective
+  /// of a macro, return a new syntax node based on this node that strips all
+  /// information that isn't supposed to be exposed as a lexical context, such
+  /// as function bodies or the members of types/extensions.
+  ///
+  /// Returns `nil` for any syntax node that isn't a lexical context.
+  public func asMacroLexicalContext() -> Syntax? {
+    switch Syntax(self).asProtocol(SyntaxProtocol.self) {
+    // Functions have their body removed.
+    case var function as WithOptionalCodeBlockSyntax & SyntaxProtocol:
+      function = function.detached
+      function.body = nil
+      return Syntax(function) as Syntax
+
+    // Closures have their body removed.
+    case var closure as ClosureExprSyntax:
+      closure = closure.detached
+      closure.statements = CodeBlockItemListSyntax()
+      return Syntax(closure)
+
+    // Nominal types and extensions have their member list cleared out.
+    case var typeOrExtension as HasTrailingMemberDeclBlock & SyntaxProtocol:
+      typeOrExtension = typeOrExtension.detached
+      typeOrExtension.memberBlock = MemberBlockSyntax(members: MemberBlockItemListSyntax())
+      return Syntax(typeOrExtension) as Syntax
+
+    // Subscripts have their accessors removed.
+    case var subscriptDecl as SubscriptDeclSyntax:
+      subscriptDecl = subscriptDecl.detached
+      subscriptDecl.accessorBlock = nil
+      return Syntax(subscriptDecl)
+
+    // Enum cases are fine as-is.
+    case is EnumCaseElementSyntax:
+      return Syntax(self.detached)
+
+    // Pattern bindings have their accessors and initializer removed.
+    case var patternBinding as PatternBindingSyntax:
+      patternBinding = patternBinding.detached
+      patternBinding.accessorBlock = nil
+      patternBinding.initializer = nil
+      return Syntax(patternBinding)
+
+    // Freestanding macros are fine as-is because if any arguments change
+    // the whole macro would have to be re-evaluated.
+    case let freestandingMacro as FreestandingMacroExpansionSyntax:
+      return Syntax(freestandingMacro.detached) as Syntax
+
+    default:
+      return nil
+    }
+  }
+
+  /// Return an array of enclosing lexical contexts for the purpose of macros,
+  /// from the innermost enclosing lexical context (first in the array) to the
+  /// outermost. If this syntax node itself is a lexical context, it will be
+  /// the innermost lexical context.
+  ///
+  /// - Parameter enclosingSyntax: provides a parent node when the operation
+  ///   has reached the outermost syntax node (i.e., it has no parent), allowing
+  ///   the caller to provide a new syntax node that can continue the walk
+  ///   to collect additional lexical contexts, e.g., from outer macro
+  ///   expansions.
+  /// - Returns: the array of enclosing lexical contexts.
+  public func allMacroLexicalContexts(
+    enclosingSyntax: (Syntax) -> Syntax? = { _ in nil }
+  ) -> [Syntax] {
+    var parentContexts: [Syntax] = []
+    var currentNode = Syntax(self)
+    while let parentNode = currentNode.parent ?? enclosingSyntax(currentNode) {
+      if let parentContext = parentNode.asMacroLexicalContext() {
+        parentContexts.append(parentContext)
+      }
+
+      currentNode = parentNode
+    }
+
+    return parentContexts
+  }
+}
+#endif