Adapt pattern binding into VariableDeclSyntax for lexical context

Author: calda

Sources/SwiftSyntaxMacroExpansion/MacroExpansion.swift

@@ -415,9 +415,10 @@ public func expandAttachedMacroWithoutCollapsing<Context: MacroExpansionContext>
           )
         )
 
-        // Insert the enclosing `VariableDeclSyntax` into the lexical context
+        // Insert the enclosing `PatternBindingSyntax`'s var decl context
+        // into the lexical context
         var context: MacroExpansionContext = context
-        if let varDeclLexicalContext = varDecl.asMacroLexicalContext() {
+        if let varDeclLexicalContext = binding.asMacroLexicalContext() {
           context = PrependLexicalContextWrapperContext(
             prependLexicalContext: [varDeclLexicalContext],
             wrapping: context

Sources/SwiftSyntaxMacros/Syntax+LexicalContext.swift

@@ -55,25 +55,24 @@ extension SyntaxProtocol {
     case is EnumCaseElementSyntax:
       return Syntax(self.detached)
 
-    // Pattern bindings have their accessors and initializer removed.
+    // Pattern bindings have their accessors and initializer removed, and wrapped in the parent variable decl.
     case var patternBinding as PatternBindingSyntax:
+      let varDecl = patternBinding.parent?.as(PatternBindingListSyntax.self)?.parent?.as(VariableDeclSyntax.self)?
+        .detached
       patternBinding = patternBinding.detached
       patternBinding.accessorBlock = nil
       patternBinding.initializer = nil
-      return Syntax(patternBinding)
-
-    // Variable declarations have their accessor blocks removed from bindings.
-    case var varDecl as VariableDeclSyntax:
-      varDecl = varDecl.detached
-      varDecl.bindings = PatternBindingListSyntax(
-        varDecl.bindings.map {
-          var binding = $0.detached
-          binding.accessorBlock = nil
-          binding.initializer = nil
-          return binding
-        }
-      )
-      return Syntax(varDecl)
+      if var varDecl {
+        varDecl.bindings = [patternBinding]
+        return Syntax(varDecl)
+      } else {
+        return Syntax(
+          VariableDeclSyntax(
+            bindingSpecifier: .keyword(.var),
+            bindings: [patternBinding]
+          )
+        )
+      }
 
     // Freestanding macros are fine as-is because if any arguments change
     // the whole macro would have to be re-evaluated.

Tests/SwiftSyntaxMacroExpansionTest/LexicalContextTests.swift

@@ -151,6 +151,14 @@ extension SyntaxProtocol {
       return singleVarName
     }
 
+    // Variable declarations with a single binding.
+    if let varDecl = self.as(VariableDeclSyntax.self),
+      varDecl.bindings.count == 1,
+      let singleVarName = varDecl.bindings.first?.singleBindingName
+    {
+      return singleVarName
+    }
+
     return nil
   }
 }
@@ -303,6 +311,21 @@ final class LexicalContextTests: XCTestCase {
       indentationWidth: indentationWidth
     )
 
+    assertMacroExpansion(
+      """
+      extension A {
+        static var staticProp = #function, secondProp = #function
+      }
+      """,
+      expandedSource: """
+        extension A {
+          static var staticProp = "staticProp", secondProp = "secondProp"
+        }
+        """,
+      macros: ["function": FunctionMacro.self],
+      indentationWidth: indentationWidth
+    )
+
     assertMacroExpansion(
       """
       func f(a: Int, _: Double, c: Int) {
@@ -546,7 +569,6 @@ final class LexicalContextTests: XCTestCase {
               await _
               try _
               unsafe _
-              contextDescription: String
               var contextDescription: String
               struct S {}
               { c in