Mark syntax interpolation errors in macro expansion

- This commit prepends `SyntaxStringInterpolationError` message with `Internal macro
  error:` when adding it as a diagnostic in
  `MacroExpansionContext.addDiagnostics`, so that macro expansion
  clarifies the error as internal to the macro, not to how it was
  applied.
- Any unrecognized errors raised and sent to `addDiagnostics` will be
  added as is, without prepending them with a message. That's consistent
  with how it works now.
- Adds a basic test for `addDiagnostics` for that behavior.
- Adds end to end test with `assertMacroExpansion`, thanks @ahoppen for
  the hint!

Author: natikgadzhi

Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift

@@ -161,15 +161,18 @@ where Self.StringInterpolation == SyntaxStringInterpolation {
   init(stringInterpolation: SyntaxStringInterpolation)
 }
 
-enum SyntaxStringInterpolationError: Error, CustomStringConvertible {
+// Used in `MacroExpansionContext` to make a nicer error message when a
+// macro expansion fails with SwiftSyntaxBuilder making a syntax node
+// with string interpolation.
+@_spi(Diagnostics) public enum SyntaxStringInterpolationError: Error, CustomStringConvertible {
   case producedInvalidNodeType(expectedType: SyntaxProtocol.Type, actualType: SyntaxProtocol.Type)
   case diagnostics([Diagnostic], tree: Syntax)
 
   static func producedInvalidNodeType<S: SyntaxProtocol>(expectedType: SyntaxProtocol.Type, actualNode: S) -> Self {
     return .producedInvalidNodeType(expectedType: expectedType, actualType: type(of: actualNode))
   }
 
-  var description: String {
+  public var description: String {
     switch self {
     case .producedInvalidNodeType(expectedType: let expectedType, actualType: let actualType):
       return "Parsing the code snippet was expected to produce a \(expectedType) but produced a \(actualType)"

Sources/SwiftSyntaxMacros/MacroExpansionContext.swift

@@ -12,6 +12,7 @@
 
 import SwiftDiagnostics
 import SwiftSyntax
+@_spi(Diagnostics) import SwiftSyntaxBuilder
 
 /// Interface to extract information about the context in which a given
 /// macro is expanded.
@@ -77,14 +78,17 @@ private struct ThrownErrorDiagnostic: DiagnosticMessage {
 }
 
 extension MacroExpansionContext {
-  /// Add diagnostics from the error thrown during macro expansion.
+  /// Adds diagnostics from the error thrown during a macro expansion.
   public func addDiagnostics(from error: Error, node: some SyntaxProtocol) {
     // Inspect the error to form an appropriate set of diagnostics.
     var diagnostics: [Diagnostic]
     if let diagnosticsError = error as? DiagnosticsError {
       diagnostics = diagnosticsError.diagnostics
     } else if let message = error as? DiagnosticMessage {
       diagnostics = [Diagnostic(node: Syntax(node), message: message)]
+    } else if let error = error as? SyntaxStringInterpolationError {
+      let diagnostic = Diagnostic(node: Syntax(node), message: ThrownErrorDiagnostic(message: "Internal macro error: \(error.description)"))
+      diagnostics = [diagnostic]
     } else {
       diagnostics = [Diagnostic(node: Syntax(node), message: ThrownErrorDiagnostic(message: String(describing: error)))]
     }

Tests/SwiftSyntaxMacroExpansionTest/MacroExpansionContextTests.swift

@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+import SwiftDiagnostics
+@_spi(Diagnostics) import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+import SwiftSyntaxMacroExpansion
+import SwiftSyntaxMacrosTestSupport
+import XCTest
+
+
+// An error that is not `SyntaxStringInterpolationError`, only used to verify
+// that other error types won't get prefixed with `Internal macro error:` when
+// passed to `MacroExpansionContext.addDiagnostics`.
+private struct DummyError: Error {
+  static let diagnosticTestError = DummyError()
+}
+
+// An extension macro that will fail with
+// `SyntaxStringInterpolationError.producedInvalidNodeType`
+private struct DummyMacro: ExtensionMacro {
+  static func expansion(
+    of node: AttributeSyntax,
+    attachedTo declaration: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
+    in context: some MacroExpansionContext
+  ) throws -> [ExtensionDeclSyntax] {
+    let ext = try ExtensionDeclSyntax("var x: Int")
+    return [ext]
+  }
+}
+
+final class MacroExpansionContextTests: XCTestCase {
+
+  func testMacroExpansionContextAddDiagnosticsAddsSwiftSyntaxInterpolationErrorsWithWrappingMessage(){
+    let context = BasicMacroExpansionContext()
+    let error = SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: DeclSyntax.self, actualType: ExprSyntax.self)
+    // Since we only care about the error switch inside of addDagnostics, we don't care about the particular node we're passing in.
+    context.addDiagnostics(from: error, node: ExprSyntax("1"))
+
+    XCTAssertEqual(context.diagnostics.count, 1)
+    XCTAssertTrue(context.diagnostics.first!.message.starts(with: "Internal macro error:"))
+  }
+
+  // Verify that any other error messages do not get "Internal macro error:" prefix.
+  func testMacroExpansionContextAddDiagnosticsUsesErrorDescriptionForDiagMessage() {
+    let context = BasicMacroExpansionContext()
+    let error = DummyError.diagnosticTestError
+
+    context.addDiagnostics(from: error, node: ExprSyntax("1"))
+    XCTAssertEqual(context.diagnostics.count, 1)
+    XCTAssertEqual(context.diagnostics.first!.message, String(describing: error))
+  }
+
+  func testMacroExpansionSyntaxInterpolationErrorGetsPrefixed() {
+    let expectedDiagnostic = DiagnosticSpec(
+      message: "Internal macro error: Parsing the code snippet was expected to produce a ExtensionDeclSyntax but produced a DeclSyntax",
+      line: 1,
+      column: 1
+    )
+
+    assertMacroExpansion(
+      "@dummy struct Foo {}",
+      expandedSource: "struct Foo {}",
+      diagnostics: [expectedDiagnostic],
+      macros: ["dummy": DummyMacro.self]
+    )
+  }
+}