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.

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,73 @@
+  //===----------------------------------------------------------------------===//
+  //
+  // 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
+  //
+  //===----------------------------------------------------------------------===//
+
+  //==========================================================================//
+  // IMPORTANT: The macros defined in this file are intended to test the      //
+  // behavior of MacroSystem. Many of them do not serve as good examples of   //
+  // how macros should be written. In particular, they often lack error       //
+  // handling because it is not needed in the few test cases in which these   //
+  // macros are invoked.                                                      //
+  //==========================================================================//
+
+import SwiftSyntax
+import SwiftDiagnostics
+@_spi(Diagnostics) import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+import SwiftSyntaxMacroExpansion
+import SwiftSyntaxMacrosTestSupport
+import XCTest
+
+//private class TestMacroExpansionContext: MacroExpansionContext {
+//  public var diagnostics = [Diagnostic]()
+//
+//  func diagnose(_ diagnostic: Diagnostic) {
+//    diagnostics.append(diagnostic)
+//  }
+//
+//  func makeUniqueName(_ name: String) -> TokenSyntax {
+//    return TokenSyntax.identifier(name)
+//  }
+//
+//  func location(
+//    of node: some SyntaxProtocol,
+//    at position: PositionInSyntaxNode,
+//    filePathMode: SourceLocationFilePathMode
+//  ) -> AbstractSourceLocation? {
+//    return nil
+//  }
+//}
+
+private struct DummyError: Error {
+  static let diagnosticTestError = DummyError()
+}
+
+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:"))
+  }
+
+  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))
+  }
+}