Address review comments

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -46,7 +46,7 @@ public let DECL_NODES: [Node] = [
     kind: .accessorBlock,
     base: .syntax,
     nameForDiagnostics: nil,
-    parserFunction: "parseGetSet",
+    parserFunction: "parseAccessorBlock",
     traits: [
       "Braced"
     ],

Sources/SwiftParser/CollectionNodes+Parsable.swift

@@ -119,7 +119,8 @@ extension MemberBlockItemListSyntax: SyntaxParseable {
 
 //==========================================================================//
 // IMPORTANT: When adding a new conformance, also add a corrsponding        //
-// conformance to SyntaxExpressibleByStringInterpolation.                   //
+// conformance to SyntaxExpressibleByStringInterpolation in                 //
+// SyntaxExpressibleByStringInterpolationConformances.swift                 //
 //==========================================================================//
 
 //==========================================================================//

Sources/SwiftParser/Declarations.swift

@@ -1151,7 +1151,7 @@ extension Parser {
     // Parse getter and setter.
     let accessor: RawAccessorBlockSyntax?
     if self.at(.leftBrace) || self.at(anyIn: AccessorDeclSyntax.AccessorSpecifierOptions.self) != nil {
-      accessor = self.parseGetSet()
+      accessor = self.parseAccessorBlock()
     } else {
       accessor = nil
     }
@@ -1265,7 +1265,7 @@ extension Parser {
 
         let accessors: RawAccessorBlockSyntax?
         if self.at(.leftBrace) || (inMemberDeclList && self.at(anyIn: AccessorDeclSyntax.AccessorSpecifierOptions.self) != nil && !self.at(.keyword(.`init`))) {
-          accessors = self.parseGetSet()
+          accessors = self.parseAccessorBlock()
         } else {
           accessors = nil
         }
@@ -1408,7 +1408,7 @@ extension Parser {
 
   /// Parse the body of a variable declaration. This can include explicit
   /// getters, setters, and observers, or the body of a computed property.
-  mutating func parseGetSet() -> RawAccessorBlockSyntax {
+  mutating func parseAccessorBlock() -> RawAccessorBlockSyntax {
     // Parse getter and setter.
     let unexpectedBeforeLBrace: RawUnexpectedNodesSyntax?
     let lbrace: RawTokenSyntax

Sources/SwiftParser/generated/LayoutNodes+Parsable.swift

@@ -30,7 +30,7 @@ extension AccessorBlockSyntax: SyntaxParseable {
       withExtendedLifetime(parser) {
       }
     }
-    let node = parser.parseGetSet()
+    let node = parser.parseAccessorBlock()
     let raw = RawSyntax(parser.parseRemainder(into: node))
     return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
   }

Sources/SwiftSyntaxMacroExpansion/IndentationUtils.swift

@@ -27,7 +27,7 @@ extension SyntaxProtocol {
 // MARK: String.indented
 
 extension String {
-  /// Indents every new line in this string literal by `indentation`.
+  /// Indents every new line in this string by `indentation`.
   ///
   /// - Note: The first line in the string gets indented as well.
   func indented(by indentation: Trivia) -> String {

Sources/SwiftSyntaxMacroExpansion/MacroExpansion.swift

@@ -403,7 +403,7 @@ public func collapse<Node: SyntaxProtocol>(
   }
 
   var expansions = expansions
-  var separator = "\n"
+  var separator = "\n\n"
 
   switch role {
   case .accessor:
@@ -427,6 +427,7 @@ public func collapse<Node: SyntaxProtocol>(
       expansions = expansions.map({ $0.indented(by: indentationWidth ?? .spaces(4)) })
       expansions[0] = "{\n" + expansions[0]
       expansions[expansions.count - 1] += "\n}"
+      separator = "\n"
     }
   case .memberAttribute:
     separator = " "

Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift

@@ -263,9 +263,11 @@ private func expandAccessorMacroWithoutExistingAccessors(
     return nil
   }
 
-  // `expandAttachedMacro` adds the `{` and `}` to wrap the accessor block.
-  // Since the entire block is indented, we start it on a new line.
-  let indentedSource = "\n" + expanded.indented(by: attachedTo.indentationOfFirstLine)
+  // `expandAttachedMacro` adds the `{` and `}` to wrap the accessor block and
+  // then indents it.
+  // Remove any indentaiton from the first line using `drop(while:)` and then
+  // prepend a space to separate it from the variable declaration
+  let indentedSource = " " + expanded.indented(by: attachedTo.indentationOfFirstLine).drop(while: { $0.isWhitespace })
   return "\(raw: indentedSource)"
 }
 
@@ -434,14 +436,14 @@ private enum MacroApplicationError: DiagnosticMessage, Error {
     switch self {
     case .accessorMacroOnVariableWithMultipleBindings:
       return """
-        swift-syntax applies macros syntactically but there is no way to represent a variable \
+        swift-syntax applies macros syntactically and there is no way to represent a variable \
         declaration with multiple bindings that have accessors syntactically. \
         While the compiler allows this expansion, swift-syntax cannot represent it and thus \
         disallows it.
         """
     case .malformedAccessor:
       return """
-        Macro returned a mal-formed accessor. Accessors should start with an introducer like 'get' or 'set'.
+        Macro returned a malformed accessor. Accessors should start with an introducer like 'get' or 'set'.
         """
     }
   }
@@ -452,8 +454,8 @@ private class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
   let macroSystem: MacroSystem
   var context: Context
   var indentationWidth: Trivia
-  /// Nodes that we have already handled in `visitAny` and that should be visited
-  /// in the node-specific handling function.
+  /// Nodes that we are currently handling in `visitAny` and that should be
+  /// visited using the node-specific handling function.
   var skipVisitAnyHandling: Set<Syntax> = []
 
   /// Store expanded extension while visiting member decls. This should be
@@ -481,8 +483,8 @@ private class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
 
     // Expand 'MacroExpansionExpr'.
     // Note that 'MacroExpansionExpr'/'MacroExpansionExprDecl' at code item
-    // position are handled by 'visit(_:CodeBlockItemListSyntax)'. Here's only
-    // expression inside other syntax node.
+    // position are handled by 'visit(_:CodeBlockItemListSyntax)'.
+    // Only expression expansions inside other syntax nodes is handled here.
     if let expanded = expandExpr(node: node) {
       return Syntax(visit(expanded))
     }
@@ -632,7 +634,7 @@ extension MacroApplication {
 
     return attributes.compactMap {
       guard case let .attribute(attribute) = $0,
-            let attributeName = attribute.attributeName.as(IdentifierTypeSyntax.self)?.name.text,
+        let attributeName = attribute.attributeName.as(IdentifierTypeSyntax.self)?.name.text,
         let macro = macroSystem.lookup(attributeName)
       else {
         return nil
@@ -673,13 +675,13 @@ extension MacroApplication {
   ) -> [ExpandedNode] {
     var result: [ExpandedNode] = []
 
-    for peerMacro in macroAttributes(attachedTo: decl, ofType: ofType) {
+    for macroAttribute in macroAttributes(attachedTo: decl, ofType: ofType) {
       do {
-        if let expanded = try expandMacro(peerMacro.attributeNode, peerMacro.definition) {
+        if let expanded = try expandMacro(macroAttribute.attributeNode, macroAttribute.definition) {
           result += expanded
         }
       } catch {
-        context.addDiagnostics(from: error, node: peerMacro.attributeNode)
+        context.addDiagnostics(from: error, node: macroAttribute.attributeNode)
       }
     }
     return result

Tests/SwiftSyntaxMacroExpansionTest/MacroSystemTests.swift

@@ -608,13 +608,10 @@ public struct UnwrapMacro: CodeItemMacro {
   }
 }
 
-public struct DeclsFromStringsMacro: DeclarationMacro {
-  public static func expansion(
-    of node: some FreestandingMacroExpansionSyntax,
-    in context: some MacroExpansionContext
-  ) throws -> [DeclSyntax] {
+public struct DeclsFromStringsMacro: DeclarationMacro, MemberMacro {
+  private static func decls(from arguments: LabeledExprListSyntax) -> [DeclSyntax] {
     var strings: [String] = []
-    for arg in node.argumentList {
+    for arg in arguments {
       guard
         let value = arg.expression.as(StringLiteralExprSyntax.self)?.representedLiteralValue
       else {
@@ -627,6 +624,24 @@ public struct DeclsFromStringsMacro: DeclarationMacro {
       "\(raw: $0)"
     }
   }
+
+  public static func expansion(
+    of node: some FreestandingMacroExpansionSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    return decls(from: node.argumentList)
+  }
+
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingMembersOf declaration: some DeclGroupSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    guard case .argumentList(let arguments) = node.arguments else {
+      return []
+    }
+    return decls(from: arguments)
+  }
 }
 
 public struct SendableConformanceMacro: ConformanceMacro {
@@ -857,8 +872,7 @@ final class MacroSystemTests: XCTestCase {
       var x: Int
       """,
       expandedSource: """
-        var x: Int
-        {
+        var x: Int {
           get {
             _x.wrappedValue
           }
@@ -958,8 +972,7 @@ final class MacroSystemTests: XCTestCase {
       """,
       expandedSource: """
         struct Foo {
-          subscript() -> Int
-          {
+          subscript() -> Int {
             get {
               return 1
             }
@@ -1064,7 +1077,7 @@ final class MacroSystemTests: XCTestCase {
       diagnostics: [
         DiagnosticSpec(
           message:
-            "swift-syntax applies macros syntactically but there is no way to represent a variable declaration with multiple bindings that have accessors syntactically. While the compiler allows this expansion, swift-syntax cannot represent it and thus disallows it.",
+            "swift-syntax applies macros syntactically and there is no way to represent a variable declaration with multiple bindings that have accessors syntactically. While the compiler allows this expansion, swift-syntax cannot represent it and thus disallows it.",
           line: 1,
           column: 1,
           severity: .error
@@ -1083,8 +1096,7 @@ final class MacroSystemTests: XCTestCase {
       var x: Int
       """,
       expandedSource: """
-        var x: Int
-        {
+        var x: Int {
           get {
             return 1
           }
@@ -1249,17 +1261,15 @@ final class MacroSystemTests: XCTestCase {
       expandedSource: """
 
         struct Point {
-          var x: Int
-          {
+          var x: Int {
             get {
               _storage[wrappedKeyPath: \\.x]
             }
             set {
               _storage[wrappedKeyPath: \\.x] = newValue
             }
           }
-          var y: Int
-          {
+          var y: Int {
             get {
               _storage[wrappedKeyPath: \\.y]
             }
@@ -1417,6 +1427,30 @@ final class MacroSystemTests: XCTestCase {
     )
   }
 
+  func testMemberDeclsFromStringLiterals() {
+    assertMacroExpansion(
+      """
+      @decls("func foo() {}", "func bar() {}"
+      struct Foo {
+        var member: Int
+      }
+      """,
+      expandedSource: """
+        struct Foo {
+          var member: Int
+
+          func foo() {
+          }
+
+          func bar() {
+          }
+        }
+        """,
+      macros: ["decls": DeclsFromStringsMacro.self],
+      indentationWidth: indentationWidth
+    )
+  }
+
   func testIndentationOfMultipleModifiers() {
     assertMacroExpansion(
       """