[Macros] Eliminate MacroResult.

Per pitch feedback, eliminate MacroResult. Instead, macro
implementations can produce diagnostics by calling `diagnose()` on the
macro evaluation context.

Author: DougGregor

Sources/_SwiftSyntaxMacros/CMakeLists.txt

@@ -10,7 +10,6 @@ add_swift_host_library(_SwiftSyntaxMacros
   ExpressionMacro.swift
   Macro.swift
   MacroExpansionContext.swift
-  MacroResult.swift
   MacroSystem+Builtin.swift
   MacroSystem+Examples.swift
   MacroSystem.swift

Sources/_SwiftSyntaxMacros/ExpressionMacro.swift

@@ -19,11 +19,12 @@ import _CompilerPluginSupport
 
 /// Describes a macro that is explicitly expanded as an expression.
 public protocol ExpressionMacro: Macro {
-  /// Evaluate a macro described by the given macro expansion expression
+  /// Expansion a macro described by the given macro expansion expression
   /// within the given context to produce a replacement expression.
   static func apply(
-    _ macro: MacroExpansionExprSyntax, in context: inout MacroExpansionContext
-  ) -> MacroResult<ExprSyntax>
+    _ expansion: MacroExpansionExprSyntax,
+    in context: inout MacroExpansionContext
+  ) -> ExprSyntax
 }
 
 #if canImport(_CompilerPluginSupport)

Sources/_SwiftSyntaxMacros/MacroExpansionContext.swift

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 import SwiftSyntax
+import SwiftDiagnostics
 
 /// System-supplied structure that provides information about the context in
 /// which a given macro is being expanded.
@@ -28,6 +29,10 @@ public struct MacroExpansionContext {
   /// Counter used to generate names local to the macro.
   var localNameCounter = 0
 
+  /// The set of diagnostics that were emitted as part of expanding the
+  /// macro.
+  public private(set) var diagnostics: [Diagnostic] = []
+
   /// Create a new macro evaluation context.
   public init(moduleName: String, fileName: String) {
     self.moduleName = moduleName
@@ -54,4 +59,9 @@ public struct MacroExpansionContext {
 
     self.init(moduleName: moduleName, fileName: fileName)
   }
+
+  /// Produce a diagnostic while expanding the macro.
+  public mutating func diagnose(_ diagnostic: Diagnostic) {
+    diagnostics.append(diagnostic)
+  }
 }

Sources/_SwiftSyntaxMacros/MacroResult.swift

@@ -29,59 +29,59 @@ private func replaceFirstLabel(
 public struct ColorLiteralMacro: ExpressionMacro {
   public static func apply(
     _ macro: MacroExpansionExprSyntax, in context: inout MacroExpansionContext
-  ) -> MacroResult<ExprSyntax> {
+  ) -> ExprSyntax {
     let argList = replaceFirstLabel(
       of: macro.argumentList, with: "_colorLiteralRed"
     )
     let initSyntax: ExprSyntax = ".init(\(argList))"
     if let leadingTrivia = macro.leadingTrivia {
-      return MacroResult(initSyntax.withLeadingTrivia(leadingTrivia))
+      return initSyntax.withLeadingTrivia(leadingTrivia)
     }
-    return MacroResult(initSyntax)
+    return initSyntax
   }
 }
 
 public struct FileLiteralMacro: ExpressionMacro {
   public static func apply(
     _ macro: MacroExpansionExprSyntax, in context: inout MacroExpansionContext
-  ) -> MacroResult<ExprSyntax> {
+  ) -> ExprSyntax {
     let argList = replaceFirstLabel(
       of: macro.argumentList, with: "fileReferenceLiteralResourceName"
     )
     let initSyntax: ExprSyntax = ".init(\(argList))"
     if let leadingTrivia = macro.leadingTrivia {
-      return MacroResult(initSyntax.withLeadingTrivia(leadingTrivia))
+      return initSyntax.withLeadingTrivia(leadingTrivia)
     }
-    return MacroResult(initSyntax)
+    return initSyntax
   }
 }
 
 public struct ImageLiteralMacro: ExpressionMacro {
   public static func apply(
     _ macro: MacroExpansionExprSyntax, in context: inout MacroExpansionContext
-  ) -> MacroResult<ExprSyntax> {
+  ) -> ExprSyntax {
     let argList = replaceFirstLabel(
       of: macro.argumentList, with: "imageLiteralResourceName"
     )
     let initSyntax: ExprSyntax = ".init(\(argList))"
     if let leadingTrivia = macro.leadingTrivia {
-      return MacroResult(initSyntax.withLeadingTrivia(leadingTrivia))
+      return initSyntax.withLeadingTrivia(leadingTrivia)
     }
-    return MacroResult(initSyntax)
+    return initSyntax
   }
 }
 
 public struct FileIDMacro: ExpressionMacro {
   public static func apply(
     _ macro: MacroExpansionExprSyntax, in context: inout MacroExpansionContext
-  ) -> MacroResult<ExprSyntax> {
+  ) -> ExprSyntax {
     // FIXME: Compiler has more sophisticated file ID computation
     let fileID = "\(context.moduleName)/\(context.fileName)"
     let fileLiteral: ExprSyntax = "\(literal: fileID)"
     if let leadingTrivia = macro.leadingTrivia {
-      return MacroResult(fileLiteral.withLeadingTrivia(leadingTrivia))
+      return fileLiteral.withLeadingTrivia(leadingTrivia)
     }
-    return MacroResult(fileLiteral)
+    return fileLiteral
   }
 }
 

Sources/_SwiftSyntaxMacros/MacroSystem+Builtin.swift

@@ -17,13 +17,13 @@ import SwiftSyntaxBuilder
 public struct StringifyMacro: ExpressionMacro {
   public static func apply(
     _ macro: MacroExpansionExprSyntax, in context: inout MacroExpansionContext
-  ) -> MacroResult<ExprSyntax> {
+  ) -> ExprSyntax {
     guard let argument = macro.argumentList.first?.expression else {
       // FIXME: Create a diagnostic for the missing argument?
-      return MacroResult(ExprSyntax(macro))
+      return ExprSyntax(macro)
     }
 
-    return MacroResult("(\(argument), \(StringLiteralExprSyntax(content: argument.description)))")
+    return "(\(argument), \(StringLiteralExprSyntax(content: argument.description)))"
   }
 }
 

Sources/_SwiftSyntaxMacros/MacroSystem+Examples.swift

@@ -63,16 +63,13 @@ public struct MacroSystem {
 class MacroApplication : SyntaxRewriter {
   let macroSystem: MacroSystem
   var context: MacroExpansionContext
-  let errorHandler: (MacroSystemError) -> Void
 
   init(
     macroSystem: MacroSystem,
-    context: MacroExpansionContext,
-    errorHandler: @escaping (MacroSystemError) -> Void
+    context: MacroExpansionContext
   ) {
     self.macroSystem = macroSystem
     self.context = context
-    self.errorHandler = errorHandler
   }
 
   override func visitAny(_ node: Syntax) -> Syntax? {
@@ -81,7 +78,7 @@ class MacroApplication : SyntaxRewriter {
     }
 
     return node.evaluateMacro(
-      with: macroSystem, context: &context, errorHandler: errorHandler
+      with: macroSystem, context: &context
     )
   }
 
@@ -108,19 +105,14 @@ extension MacroSystem {
   ///
   /// - Parameter node: The syntax node in which macros will be evaluated.
   /// - Parameter context: The context in which macros are evaluated.
-  /// - Parameter errorHandler: Errors encountered during traversal will
-  ///   be passed to the error handler.
   /// - Returns: the syntax tree with all macros evaluated.
   public func evaluateMacros<Node: SyntaxProtocol>(
     node: Node,
-    in context: inout MacroExpansionContext,
-    errorHandler: (MacroSystemError) -> Void
+    in context: inout MacroExpansionContext
   ) -> Syntax {
-    return withoutActuallyEscaping(errorHandler) { errorHandler in
-      let applier = MacroApplication(
-        macroSystem: self, context: context, errorHandler: errorHandler
-      )
-      return applier.visit(Syntax(node))
-    }
+    let applier = MacroApplication(
+      macroSystem: self, context: context
+    )
+    return applier.visit(Syntax(node))
   }
 }

Sources/_SwiftSyntaxMacros/MacroSystem.swift

@@ -34,27 +34,14 @@ extension MacroExpansionExprSyntax {
   /// result and (possibly) some diagnostics.
   func evaluateMacro(
     _ macro: Macro.Type,
-    in context: inout MacroExpansionContext,
-    errorHandler: (MacroSystemError) -> Void
+    in context: inout MacroExpansionContext
   ) -> ExprSyntax {
     guard let exprMacro = macro as? ExpressionMacro.Type else {
-      errorHandler(.requiresExpressionMacro(macro: macro, node: Syntax(self)))
       return ExprSyntax(self)
     }
 
     // Handle the rewrite.
-    let result = exprMacro.apply(disconnectedCopy(), in: &context)
-
-    // Report diagnostics, if there were any.
-    if !result.diagnostics.isEmpty {
-      errorHandler(
-        .evaluationDiagnostics(
-          node: Syntax(self), diagnostics: result.diagnostics
-        )
-      )
-    }
-
-    return result.rewritten
+    return exprMacro.apply(disconnectedCopy(), in: &context)
   }
 }
 
@@ -81,16 +68,13 @@ extension MacroExpansionDeclSyntax {
   /// result and (possibly) some diagnostics.
   func evaluateMacro(
     _ macro: Macro.Type,
-    in context: inout MacroExpansionContext,
-    errorHandler: (MacroSystemError) -> Void
+    in context: inout MacroExpansionContext
   ) -> Syntax {
     // TODO: declaration/statement macros
 
     // Fall back to evaluating as an expression macro.
     return Syntax(
-      asMacroExpansionExpr().evaluateMacro(
-        macro, in: &context, errorHandler: errorHandler
-      )
+      asMacroExpansionExpr().evaluateMacro(macro, in: &context)
     )
   }
 }
@@ -120,8 +104,7 @@ extension Syntax {
   /// some kind.
   public func evaluateMacro(
     with macroSystem: MacroSystem,
-    context: inout MacroExpansionContext,
-    errorHandler: (MacroSystemError) -> Void
+    context: inout MacroExpansionContext
   ) -> Syntax {
     // If this isn't a macro evaluation node, do nothing.
     guard let macroName = evaluatedMacroName else {
@@ -130,21 +113,16 @@ extension Syntax {
 
     // Look for a macro with the given name. Otherwise, fail.
     guard let macro = macroSystem.macros[macroName] else {
-      errorHandler(.unknownMacro(name: macroName, node: self))
       return self
     }
 
     switch self.as(SyntaxEnum.self) {
     case .macroExpansionDecl(let expansion):
-      return expansion.evaluateMacro(
-        macro, in: &context, errorHandler: errorHandler
-      )
+      return expansion.evaluateMacro(macro, in: &context)
 
     case .macroExpansionExpr(let expansion):
       return Syntax(
-        expansion.evaluateMacro(
-          macro, in: &context, errorHandler: errorHandler
-        )
+        expansion.evaluateMacro(macro, in: &context)
       )
 
     default:

Sources/_SwiftSyntaxMacros/Syntax+MacroEvaluation.swift

@@ -248,11 +248,9 @@ class ExpandMacros: ParsableCommand {
       var diags = ParseDiagnosticsGenerator.diagnostics(for: tree)
       let transformedTree = MacroSystem.exampleSystem.evaluateMacros(
         node: resultTree, in: &context
-      ) { error in
-        if case let .evaluationDiagnostics(_, diagnostics) = error {
-          diags.append(contentsOf: diagnostics)
-        }
-      }
+      )
+
+      diags.append(contentsOf: context.diagnostics)
 
       print(transformedTree)
       print(DiagnosticsFormatter.annotatedSource(tree: tree, diags: diags))

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

@@ -21,15 +21,15 @@ import _SwiftSyntaxTestSupport
 struct CheckContextIndependenceMacro: ExpressionMacro {
   static func apply(
     _ macro: MacroExpansionExprSyntax,
-    in context: inout MacroExpansionContext) -> MacroResult<ExprSyntax> {
+    in context: inout MacroExpansionContext) -> ExprSyntax {
 
     // Should not have a parent.
     XCTAssertNil(macro.parent)
 
     // Absolute starting position should be zero.
     XCTAssertEqual(macro.position.utf8Offset, 0)
 
-    return .init(ExprSyntax(macro))
+    return ExprSyntax(macro)
   }
 }
 
@@ -44,7 +44,7 @@ final class MacroSystemTests: XCTestCase {
       moduleName: "MyModule", fileName: "test.swift"
     )
     let transformedSF = MacroSystem.exampleSystem.evaluateMacros(
-      node: sf, in: &context, errorHandler: { error in }
+      node: sf, in: &context
     )
     AssertStringsEqualWithDiff(
       transformedSF.description,
@@ -67,7 +67,7 @@ final class MacroSystemTests: XCTestCase {
       moduleName: "MyModule", fileName: "test.swift"
     )
     let transformedSF = MacroSystem.exampleSystem.evaluateMacros(
-      node: sf, in: &context, errorHandler: { error in }
+      node: sf, in: &context
     )
     AssertStringsEqualWithDiff(
       transformedSF.description,
@@ -89,7 +89,7 @@ final class MacroSystemTests: XCTestCase {
       moduleName: "MyModule", fileName: "taylor.swift"
     )
     let transformedSF = MacroSystem.exampleSystem.evaluateMacros(
-      node: sf, in: &context, errorHandler: { error in }
+      node: sf, in: &context
     )
     AssertStringsEqualWithDiff(
       transformedSF.description,
@@ -122,7 +122,7 @@ final class MacroSystemTests: XCTestCase {
       moduleName: "MyModule", fileName: "taylor.swift"
     )
     let transformedSF = system.evaluateMacros(
-      node: sf, in: &context, errorHandler: { error in }
+      node: sf, in: &context
     )
     AssertStringsEqualWithDiff(
       transformedSF.description,