[Parser] Replace #function with a macro.

Stop creating `PoundFunctionSyntaxExpr` nodes in the parser. Implement
a macro version instead.

Author: DougGregor

Sources/SwiftParser/Expressions.swift

@@ -1035,12 +1035,6 @@ extension Parser {
         poundFilePath: tok,
         arena: self.arena
       ))
-    case (.poundFunctionKeyword, let handle)?:
-      let tok = self.eat(handle)
-      return RawExprSyntax(RawPoundFunctionExprSyntax(
-        poundFunction: tok,
-        arena: self.arena
-      ))
     case (.__function__Keyword, let handle)?:
       let tok = self.eat(handle)
       return RawExprSyntax(RawPoundFunctionExprSyntax(

Sources/SwiftParser/Lexer.swift

@@ -1543,7 +1543,6 @@ extension Lexer.Cursor {
     case "file": kind = .poundFileKeyword
     case "fileID": kind = .poundFileIDKeyword
     case "filePath": kind = .poundFilePathKeyword
-    case "function": kind = .poundFunctionKeyword
     case "assert": kind = .poundAssertKeyword
     case "sourceLocation": kind = .poundSourceLocationKeyword
     case "warning": kind = .poundWarningKeyword

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -743,7 +743,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
   case poundFileKeyword
   case poundFileLiteralKeyword
   case poundFilePathKeyword
-  case poundFunctionKeyword
   case poundImageLiteralKeyword
   case poundKeyPathKeyword
   case poundSelectorKeyword
@@ -780,7 +779,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
     case .poundFileKeyword: self = .poundFileKeyword
     case .poundFileLiteralKeyword: self = .poundFileLiteralKeyword
     case .poundFilePathKeyword: self = .poundFilePathKeyword
-    case .poundFunctionKeyword: self = .poundFunctionKeyword
     case .poundImageLiteralKeyword: self = .poundImageLiteralKeyword
     case .poundKeyPathKeyword: self = .poundKeyPathKeyword
     case .poundSelectorKeyword: self = .poundSelectorKeyword
@@ -820,7 +818,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
     case .poundFileKeyword: return .poundFileKeyword
     case .poundFileLiteralKeyword: return .poundFileLiteralKeyword
     case .poundFilePathKeyword: return .poundFilePathKeyword
-    case .poundFunctionKeyword: return .poundFunctionKeyword
     case .poundImageLiteralKeyword: return .poundImageLiteralKeyword
     case .poundKeyPathKeyword: return .poundKeyPathKeyword
     case .poundSelectorKeyword: return .poundSelectorKeyword

Sources/SwiftSyntaxMacros/MacroEvaluationContext.swift

@@ -3,11 +3,18 @@ import SwiftSyntax
 /// System-supplied structure that provides information about the context in
 /// which a given macro is being expanded.
 public struct MacroEvaluationContext {
+  /// The name of the module in which the macro is being evaluated.
+  public let moduleName: String
+
   /// Used to map the provided syntax nodes into source locations.
   public let sourceLocationConverter: SourceLocationConverter
 
   @_spi(Testing)
-  public init(sourceLocationConverter: SourceLocationConverter) {
+  public init(
+    moduleName: String,
+    sourceLocationConverter: SourceLocationConverter
+  ) {
+    self.moduleName = moduleName
     self.sourceLocationConverter = sourceLocationConverter
   }
 }

Sources/SwiftSyntaxMacros/MacroSystem+Examples.swift

@@ -28,6 +28,123 @@ struct LineMacro: ExpressionMacro {
   }
 }
 
+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
+  }
+}
+
+struct FunctionMacro: ExpressionMacro {
+  static var name: String { "function" }
+
+  /// 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
+  }
+
+  static func apply(
+    _ macro: MacroExpansionExprSyntax, in context: MacroEvaluationContext
+  ) -> MacroResult<ExprSyntax> {
+    let name = findEnclosingName(macro) ?? context.moduleName
+    let literal: ExprSyntax = #""\#(name)""#
+    if let leadingTrivia = macro.leadingTrivia {
+      return .init(literal.withLeadingTrivia(leadingTrivia))
+    }
+
+    return .init(literal)
+  }
+}
+
 struct Stringify: ExpressionMacro {
   static var name: String { "stringify" }
 
@@ -61,6 +178,7 @@ extension MacroSystem {
   public static var exampleSystem: MacroSystem {
     var macroSystem = MacroSystem()
     try! macroSystem.add(ColumnMacro.self)
+    try! macroSystem.add(FunctionMacro.self)
     try! macroSystem.add(LineMacro.self)
     try! macroSystem.add(Stringify.self)
     try! macroSystem.add(ColorLiteral.self)

Sources/swift-parser-cli/swift-parser-cli.swift

@@ -227,7 +227,9 @@ class ExpandMacros: ParsableCommand {
       }
 
       let converter = SourceLocationConverter(file: self.sourceFile, tree: resultTree)
-      let context = MacroEvaluationContext(sourceLocationConverter: converter)
+      let context = MacroEvaluationContext(
+        moduleName: "MyModule", sourceLocationConverter: converter
+      )
       var diags = ParseDiagnosticsGenerator.diagnostics(for: tree)
       let transformedTree = MacroSystem.exampleSystem.evaluateMacros(
         node: resultTree, in: context

Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift

@@ -15,7 +15,9 @@ final class MacroSystemTests: XCTestCase {
       let c = #column
       """
     let converter = SourceLocationConverter(file: "test.swift", tree: sf)
-    let context = MacroEvaluationContext(sourceLocationConverter: converter)
+    let context = MacroEvaluationContext(
+      moduleName: "MyModule", sourceLocationConverter: converter
+    )
     let transformedSF = MacroSystem.exampleSystem.evaluateMacros(
       node: sf, in: context, errorHandler: { error in }
     )
@@ -30,4 +32,76 @@ final class MacroSystemTests: XCTestCase {
       """
     )
   }
+
+  func testPoundFunctionExpansion() {
+    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 converter = SourceLocationConverter(file: "test.swift", tree: sf)
+    let context = MacroEvaluationContext(
+      moduleName: "MyModule", sourceLocationConverter: converter
+    )
+    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"
+      }
+      """
+    )
+  }
 }