[Macros] Support user-defined macros as compiler plugins

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.

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,54 @@ 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 sourceFileText = String(decoding: sourceFileTextBuffer, as: UTF8.self)
+    // TODO: `SourceLocationConverter.init(file:source:)` should be able to
+    // accept a buffer.
+    let converter = SourceLocationConverter(
+      file: filePath, source: sourceFileText)
+    let context = MacroEvaluationContext(
+      moduleName: targetModuleName, sourceLocationConverter: converter)
+    let meeTextBuffer = UnsafeBufferPointer(
+      start: localSourceText, count: localSourceTextCount)
+    var parser = Parser(meeTextBuffer)
+    let mee = try! MacroExpansionExprSyntax.parse(from: &parser)
+
+    // 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)
+      _ = result.initialize(from: buffer)
+      return (UnsafePointer(result.baseAddress), result.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