[Macros] Support user-defined macros as compiler plugins (#1022)

Make `Macro` refine `_CompilerPlugin` protocol when `_CompilerPluginSupport` exists. (`_CompilerPluginSupport` may not exist when ASTGen or SwiftCompilerSources is built with host tools.) This enables macros to talk to the compiler without an ABI-stable SwiftSyntax.

Friend PR: swiftlang/swift#61734

Author: rxwei

Sources/_SwiftSyntaxMacros/ExpressionMacro.swift

@@ -11,6 +11,10 @@
 //===----------------------------------------------------------------------===//
 
 import SwiftSyntax
+import SwiftParser
+#if canImport(_CompilerPluginSupport)
+import _CompilerPluginSupport
+#endif
 
 /// Describes a macro that is explicitly expanded as an expression.
 public protocol ExpressionMacro: Macro {
@@ -20,3 +24,57 @@ public protocol ExpressionMacro: Macro {
     _ macro: MacroExpansionExprSyntax, in context: MacroEvaluationContext
   ) -> MacroResult<ExprSyntax>
 }
+
+#if canImport(_CompilerPluginSupport)
+extension ExpressionMacro {
+  public static func _kind() -> _CompilerPluginKind {
+    .expressionMacro
+  }
+
+  public static func _rewrite(
+    targetModuleName: UnsafePointer<UInt8>,
+    targetModuleNameCount: Int,
+    filePath: UnsafePointer<UInt8>,
+    filePathCount: Int,
+    sourceFileText: UnsafePointer<UInt8>,
+    sourceFileTextCount: Int,
+    localSourceText: UnsafePointer<UInt8>,
+    localSourceTextCount: Int
+  ) -> (UnsafePointer<UInt8>?, count: Int) {
+    let targetModuleNameBuffer = UnsafeBufferPointer(
+      start: filePath, count: targetModuleNameCount)
+    let targetModuleName = String(
+      decoding: targetModuleNameBuffer, as: UTF8.self)
+    let filePathBuffer = UnsafeBufferPointer(
+      start: filePath, count: filePathCount)
+    let filePath = String(decoding: filePathBuffer, as: UTF8.self)
+    let sourceFileTextBuffer = UnsafeBufferPointer(
+      start: sourceFileText, count: sourceFileTextCount)
+    let sourceFileString = String(decoding: sourceFileTextBuffer, as: UTF8.self)
+    let sourceFileSyntax = Parser.parse(source: sourceFileString)
+    let converter = SourceLocationConverter(
+      file: filePath, tree: sourceFileSyntax)
+    let context = MacroEvaluationContext(
+      moduleName: targetModuleName, sourceLocationConverter: converter)
+    let meePosition = AbsolutePosition(
+      utf8Offset: localSourceText.distance(to: localSourceText))
+    guard let meeStartToken = sourceFileSyntax.token(at: meePosition),
+          let mee = meeStartToken.parent?.as(MacroExpansionExprSyntax.self)
+    else {
+      fatalError("Unable to locate 'MacroExpansionExprSyntax'")
+    }
+
+    // Evaluate the macro.
+    let evalResult = apply(mee, in: context)
+
+    var resultString = "\(evalResult.rewritten)"
+    return resultString.withUTF8 { buffer in
+      let result = UnsafeMutableBufferPointer<UInt8>.allocate(
+        capacity: buffer.count + 1)
+      _ = result.initialize(from: buffer)
+      result[buffer.count] = 0
+      return (UnsafePointer(result.baseAddress), buffer.count)
+    }
+  }
+}
+#endif

Sources/_SwiftSyntaxMacros/Macro.swift

@@ -9,10 +9,16 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
+
 import SwiftSyntax
+#if canImport(_CompilerPluginSupport)
+import _CompilerPluginSupport
+#else
+public typealias _CompilerPlugin = Any
+#endif
 
 /// Describes a macro.
-public protocol Macro {
+public protocol Macro: _CompilerPlugin {
   /// The name of this macro.
   static var name: String { get }
 
@@ -39,3 +45,16 @@ extension Macro {
   /// Default, empty documentation string for macros.
   public static var documentation: String { "" }
 }
+
+#if canImport(_CompilerPluginSupport)
+extension Macro {
+  public static func _name() -> (UnsafePointer<UInt8>, count: Int) {
+    var name = name
+    return name.withUTF8 { buffer in
+      let result = UnsafeMutablePointer<UInt8>.allocate(capacity: buffer.count)
+      result.initialize(from: buffer.baseAddress!, count: buffer.count)
+      return (UnsafePointer(result), count: buffer.count)
+    }
+  }
+}
+#endif