[Macros] Pass macro role for freestanding macro expansion

Macros can only have a single freestanding macro role, so that their
expansion is unambiguous. However, that restriction is at the level of a
macro declaration, and is not reflected in a similar restriction on the
set of macro protocols to which a macro implementation can conform.
Therefore, have the compiler pass a freestanding macro role through to
macro expansion in the same way that we do for attached macros, and
use that to determine which macro protocol to use.

Part of fixing rdar://110418969.

Author: DougGregor

Sources/SwiftCompilerPluginMessageHandling/CompilerPluginMessageHandler.swift

@@ -87,9 +87,10 @@ extension CompilerPluginMessageHandler {
       )
       try self.sendMessage(.getCapabilityResult(capability: capability))
 
-    case .expandFreestandingMacro(let macro, let discriminator, let expandingSyntax):
+    case .expandFreestandingMacro(let macro, let macroRole, let discriminator, let expandingSyntax):
       try expandFreestandingMacro(
         macro: macro,
+        macroRole: macroRole,
         discriminator: discriminator,
         expandingSyntax: expandingSyntax
       )

Sources/SwiftCompilerPluginMessageHandling/Diagnostics.swift

@@ -19,6 +19,7 @@ enum MacroExpansionError: String {
   case unmathedMacroRole = "macro doesn't conform to required macro role"
   case freestandingMacroSyntaxIsNotMacro = "macro syntax couldn't be parsed"
   case invalidExpansionMessage = "internal message error; please file a bug report"
+  case invalidMacroRole = "invalid macro role for expansion"
 }
 
 extension MacroExpansionError: DiagnosticMessage {

Sources/SwiftCompilerPluginMessageHandling/Macros.swift

@@ -26,6 +26,7 @@ extension CompilerPluginMessageHandler {
   /// Expand `@freestainding(XXX)` macros.
   func expandFreestandingMacro(
     macro: PluginMessage.MacroReference,
+    macroRole pluginMacroRole: PluginMessage.MacroRole?,
     discriminator: String,
     expandingSyntax: PluginMessage.Syntax
   ) throws {
@@ -46,8 +47,23 @@ extension CompilerPluginMessageHandler {
         throw MacroExpansionError.macroTypeNotFound
       }
 
+      let macroRole: MacroRole
+      if let pluginMacroRole {
+        switch pluginMacroRole {
+        case .expression: macroRole = .expression
+        case .declaration: macroRole = .declaration
+        case .codeItem: macroRole = .codeItem
+
+        case .accessor, .conformance, .member, .memberAttribute, .peer:
+          throw MacroExpansionError.invalidMacroRole
+        }
+      } else {
+        macroRole = try inferFreestandingMacroRole(definition: macroDefinition)
+      }
+
       expandedSource = SwiftSyntaxMacroExpansion.expandFreestandingMacro(
         definition: macroDefinition,
+        macroRole: macroRole,
         node: macroSyntax,
         in: context
       )

Sources/SwiftCompilerPluginMessageHandling/PluginMessages.swift

@@ -20,6 +20,7 @@ internal enum HostToPluginMessage: Codable {
   /// Expand a '@freestanding' macro.
   case expandFreestandingMacro(
     macro: PluginMessage.MacroReference,
+    macroRole: PluginMessage.MacroRole? = nil,
     discriminator: String,
     syntax: PluginMessage.Syntax
   )

Sources/SwiftSyntaxMacroExpansion/MacroExpansion.swift

@@ -25,24 +25,26 @@ private enum MacroExpansionError: String, Error, CustomStringConvertible {
 ///
 /// - Parameters:
 ///   - definition: a type conforms to one of freestanding `Macro` protocol.
+///   - macroRole: indicates which `Macro` protocol expansion should be performed
 ///   - node: macro expansion syntax node (e.g. `#macroName(argument)`).
 ///   - in: context of the expansion.
 /// - Returns: expanded source text. Upon failure (i.e. `defintion.expansion()`
 ///   throws) returns `nil`, and the diagnostics representing the `Error` are
 ///   guaranteed to be added to context.
 public func expandFreestandingMacro(
   definition: Macro.Type,
+  macroRole: MacroRole,
   node: FreestandingMacroExpansionSyntax,
   in context: some MacroExpansionContext
 ) -> String? {
   do {
     func _expand(node: some FreestandingMacroExpansionSyntax) throws -> String {
       let expandedSyntax: Syntax
-      switch definition {
-      case let exprMacroDef as ExpressionMacro.Type:
+      switch (macroRole, definition) {
+      case (.expression, let exprMacroDef as ExpressionMacro.Type):
         expandedSyntax = try Syntax(exprMacroDef.expansion(of: node, in: context))
 
-      case let declMacroDef as DeclarationMacro.Type:
+      case (.declaration, let declMacroDef as DeclarationMacro.Type):
         var rewritten = try declMacroDef.expansion(of: node, in: context)
         // Copy attributes and modifiers to the generated decls.
         if let expansionDecl = node.as(MacroExpansionDeclSyntax.self) {
@@ -60,12 +62,15 @@ public func expandFreestandingMacro(
           )
         )
 
-      case let codeItemMacroDef as CodeItemMacro.Type:
+      case (.codeItem, let codeItemMacroDef as CodeItemMacro.Type):
         let rewritten = try codeItemMacroDef.expansion(of: node, in: context)
         expandedSyntax = Syntax(CodeBlockItemListSyntax(rewritten))
 
-      default:
+      case (.expression, _), (.declaration, _), (.codeItem, _):
         throw MacroExpansionError.unmathedMacroRole
+
+      case (.accessor, _), (.memberAttribute, _), (.member, _), (.peer, _), (.conformance, _), (.codeItem, _):
+        fatalError("macro role \(macroRole) is not a freestanding macro")
       }
       return expandedSyntax.formattedExpansion(definition.formatMode)
     }
@@ -76,6 +81,39 @@ public func expandFreestandingMacro(
   }
 }
 
+/// Try to infer the freestanding macro role from the type definition itself.
+///
+/// This is a workaround for older compilers with a newer plugin
+public func inferFreestandingMacroRole(definition: Macro.Type) throws -> MacroRole {
+  switch definition {
+  case is ExpressionMacro.Type: return .expression
+  case is DeclarationMacro.Type: return .declaration
+  case is CodeItemMacro.Type: return .codeItem
+
+  default:
+    throw MacroExpansionError.unmathedMacroRole
+  }
+}
+
+@available(*, deprecated, message: "pass a macro role, please!")
+public func expandFreestandingMacro(
+  definition: Macro.Type,
+  node: FreestandingMacroExpansionSyntax,
+  in context: some MacroExpansionContext
+) -> String? {
+  do {
+    return expandFreestandingMacro(
+      definition: definition,
+      macroRole: try inferFreestandingMacroRole(definition: definition),
+      node: node,
+      in: context
+    )
+  } catch {
+    context.addDiagnostics(from: error, node: node)
+    return nil
+  }
+}
+
 /// Expand `@attached(XXX)` macros.
 ///
 /// - Parameters: