[Macros] "Disconnect" macro expansion expression syntax from its parent.

Providing the macro expansion syntax node directly to the macro
implementation allowed those implementations to chase its parent
pointer, which indirectly exposed the full source code of the enclosing
file to the macro implementation. "Disconnect" the syntax node from
its parent so the syntax node is independent of all other source code
in the file.

Another sample macro implementation, `#function`, is now
unusable---but this is a better model for incremental builds.

Author: DougGregor

Sources/_SwiftSyntaxMacros/MacroSystem+Builtin.swift

@@ -13,121 +13,6 @@
 import SwiftSyntax
 import SwiftSyntaxBuilder
 
-extension PatternBindingSyntax {
-  /// When the variable is declaring a single binding, produce the name of
-  /// that binding.
-  fileprivate var singleBindingName: String? {
-    if let identifierPattern = pattern.as(IdentifierPatternSyntax.self) {
-      return identifierPattern.identifier.text
-    }
-
-    return nil
-  }
-}
-
-public struct FunctionMacro: ExpressionMacro {
-  /// Form a function name.
-  private static func formFunctionName(
-    _ baseName: String, _ parameters: ParameterClauseSyntax?,
-    isSubscript: Bool = false
-  ) -> String {
-    let argumentNames: [String] = parameters?.parameterList.map { param in
-      if let argumentName = param.firstName?.text,
-         !isSubscript || param.secondName != nil {
-        return "\(argumentName):"
-      }
-
-      return "_:"
-    } ?? []
-
-    return "\(baseName)(\(argumentNames.joined(separator: "")))"
-  }
-
-  private static func findEnclosingName(
-    _ macro: MacroExpansionExprSyntax
-  ) -> String? {
-    var currentNode = Syntax(macro)
-    while let parent = currentNode.parent {
-      switch parent.as(SyntaxEnum.self) {
-      case .accessorDecl(let accessor):
-        if let accessorList = accessor.parent?.as(AccessorListSyntax.self),
-           let accessorBlock = accessorList.parent?.as(AccessorBlockSyntax.self),
-           let binding = accessorBlock.parent?.as(PatternBindingSyntax.self),
-           let varName = binding.singleBindingName {
-          return varName
-        }
-
-        break
-
-      case .functionDecl(let function):
-        return formFunctionName(
-          function.identifier.text, function.signature.input
-        )
-
-      case .initializerDecl(let initializer):
-        return formFunctionName("init", initializer.signature.input)
-
-      case .subscriptDecl(let subscriptDecl):
-        return formFunctionName(
-          "subscript", subscriptDecl.indices, isSubscript: true
-        )
-
-      case .enumCaseElement(let enumCase):
-        return formFunctionName(
-          enumCase.identifier.text, enumCase.associatedValue
-        )
-
-      case .structDecl(let structDecl):
-        return structDecl.identifier.text
-
-      case .enumDecl(let enumDecl):
-        return enumDecl.identifier.text
-
-      case .classDecl(let classDecl):
-        return classDecl.identifier.text
-
-      case .actorDecl(let actorDecl):
-        return actorDecl.identifier.text
-
-      case .protocolDecl(let protocolDecl):
-        return protocolDecl.identifier.text
-
-      case .extensionDecl(let extensionDecl):
-        // FIXME: It would be nice to be able to switch on type syntax...
-        let extendedType = extensionDecl.extendedType
-        if let simple = extendedType.as(SimpleTypeIdentifierSyntax.self) {
-          return simple.name.text
-        }
-
-        if let member = extendedType.as(MemberTypeIdentifierSyntax.self) {
-          return member.name.text
-        }
-
-        return nil
-
-      default:
-        break
-      }
-
-      currentNode = parent
-    }
-
-    return nil
-  }
-
-  public static func apply(
-    _ macro: MacroExpansionExprSyntax, in context: inout MacroExpansionContext
-  ) -> MacroResult<ExprSyntax> {
-    let name = findEnclosingName(macro) ?? context.moduleName
-    let literal: ExprSyntax = "\(literal: name)"
-    if let leadingTrivia = macro.leadingTrivia {
-      return .init(literal.withLeadingTrivia(leadingTrivia))
-    }
-
-    return .init(literal)
-  }
-}
-
 /// Replace the label of the first element in the tuple with the given
 /// new label.
 private func replaceFirstLabel(
@@ -205,7 +90,6 @@ extension MacroSystem {
     var macroSystem = MacroSystem()
     try! macroSystem.add(ColorLiteralMacro.self, name: "colorLiteral")
     try! macroSystem.add(FileIDMacro.self, name: "fileID")
-    try! macroSystem.add(FunctionMacro.self, name: "function")
     try! macroSystem.add(ImageLiteralMacro.self, name: "imageLiteral")
     return macroSystem
   }()

Sources/_SwiftSyntaxMacros/Syntax+MacroEvaluation.swift

@@ -14,6 +14,22 @@ import SwiftDiagnostics
 import SwiftSyntax
 
 extension MacroExpansionExprSyntax {
+  private func disconnectedCopy() -> MacroExpansionExprSyntax {
+    MacroExpansionExprSyntax(
+      unexpectedBeforePoundToken, poundToken: poundToken,
+      unexpectedBetweenPoundTokenAndMacro, macro: macro,
+      genericArguments: genericArguments,
+      unexpectedBetweenGenericArgumentsAndLeftParen, leftParen: leftParen,
+      unexpectedBetweenLeftParenAndArgumentList, argumentList: argumentList,
+      unexpectedBetweenArgumentListAndRightParen, rightParen: rightParen,
+      unexpectedBetweenRightParenAndTrailingClosure,
+      trailingClosure: trailingClosure,
+      unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures,
+      additionalTrailingClosures: additionalTrailingClosures,
+      unexpectedAfterAdditionalTrailingClosures
+    )
+  }
+
   /// Evaluate the given macro for this syntax node, producing the expanded
   /// result and (possibly) some diagnostics.
   func evaluateMacro(
@@ -27,7 +43,7 @@ extension MacroExpansionExprSyntax {
     }
 
     // Handle the rewrite.
-    let result = exprMacro.apply(self, in: &context)
+    let result = exprMacro.apply(disconnectedCopy(), in: &context)
 
     // Report diagnostics, if there were any.
     if !result.diagnostics.isEmpty {

Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift

@@ -16,6 +16,23 @@ import SwiftSyntaxBuilder
 @_spi(Testing) import _SwiftSyntaxMacros
 import _SwiftSyntaxTestSupport
 
+/// Macro whose only purpose is to ensure that we cannot see "out" of the
+/// macro expansion syntax node we were given.
+struct CheckContextIndependenceMacro: ExpressionMacro {
+  static func apply(
+    _ macro: MacroExpansionExprSyntax,
+    in context: inout MacroExpansionContext) -> MacroResult<ExprSyntax> {
+
+    // Should not have a parent.
+    XCTAssertNil(macro.parent)
+
+    // Absolute starting position should be zero.
+    XCTAssertEqual(macro.position.utf8Offset, 0)
+
+    return .init(ExprSyntax(macro))
+  }
+}
+
 final class MacroSystemTests: XCTestCase {
   func testExpressionExpansion() {
     let sf: SourceFileSyntax =
@@ -63,104 +80,56 @@ final class MacroSystemTests: XCTestCase {
     )
   }
 
-  func testPoundFunctionExpansion() {
+  func testFileExpansions() {
     let sf: SourceFileSyntax =
       """
-      func f(a: Int, _: Double, c: Int) {
-        print(#function)
-      }
-
-      struct X {
-        var computed: String {
-          get {
-            #function
-          }
-        }
-
-        init(from: String) {
-          #function
-        }
-
-        subscript(a: Int) -> String {
-          #function
-        }
-
-        subscript(a a: Int) -> String {
-          #function
-        }
-      }
-
-      extension A {
-        static var staticProp: String = #function
-      }
+      let b = #fileID
       """
     var context = MacroExpansionContext(
-      moduleName: "MyModule", fileName: "test.swift"
+      moduleName: "MyModule", fileName: "taylor.swift"
     )
     let transformedSF = MacroSystem.exampleSystem.evaluateMacros(
       node: sf, in: &context, errorHandler: { error in }
     )
     AssertStringsEqualWithDiff(
       transformedSF.description,
       """
-      func f(a: Int, _: Double, c: Int) {
-        print("f(a:_:c:)")
-      }
-
-      struct X {
-        var computed: String {
-          get {
-            "computed"
-          }
-        }
-
-        init(from: String) {
-          "init(from:)"
-        }
-
-        subscript(a: Int) -> String {
-          "subscript(_:)"
-        }
-
-        subscript(a a: Int) -> String {
-          "subscript(a:)"
-        }
-      }
-
-      extension A {
-        static var staticProp: String = "A"
-      }
+      let b = "MyModule/taylor.swift"
       """
     )
   }
 
-  func testFileExpansions() {
+  func testContextUniqueLocalNames() {
+    var context = MacroExpansionContext(
+      moduleName: "MyModule", fileName: "taylor.swift"
+    )
+
+    let t1 = context.createUniqueLocalName()
+    let t2 = context.createUniqueLocalName()
+    XCTAssertNotEqual(t1.description, t2.description)
+    XCTAssertEqual(t1.description, "__macro_local_0")
+  }
+
+  func testContextIndependence() {
+    var system = MacroSystem()
+    try! system.add(CheckContextIndependenceMacro.self, name: "checkContext")
+
     let sf: SourceFileSyntax =
       """
-      let b = #fileID
+      let b = #checkContext
       """
     var context = MacroExpansionContext(
       moduleName: "MyModule", fileName: "taylor.swift"
     )
-    let transformedSF = MacroSystem.exampleSystem.evaluateMacros(
+    let transformedSF = system.evaluateMacros(
       node: sf, in: &context, errorHandler: { error in }
     )
     AssertStringsEqualWithDiff(
       transformedSF.description,
       """
-      let b = "MyModule/taylor.swift"
+      let b = #checkContext
       """
     )
-  }
 
-  func testContextUniqueLocalNames() {
-    var context = MacroExpansionContext(
-      moduleName: "MyModule", fileName: "taylor.swift"
-    )
-
-    let t1 = context.createUniqueLocalName()
-    let t2 = context.createUniqueLocalName()
-    XCTAssertNotEqual(t1.description, t2.description)
-    XCTAssertEqual(t1.description, "__macro_local_0")
   }
 }