Make SyntaxStringInterpolationInvalidTokenTypeError public

This commit splits `SyntaxStringInterpolationError` into two error
types:
- `SyntaxStringInterpolationInvalidTokenTypeError` for situations
  when interpolation resulted in a wrong token type, and
- `SyntaxStringInterpolationDiagnosticError` when another error occured,
  and the user provides additional diagnostics with the error.

Additionally:
- The `SyntaxStringInterpolationInvalidTokenTypeError` is now `public` so
other clients can catch it.
- Both error types are structs instead of enums.
- All invocation spots are updated to match the API.

Author: natikgadzhi

Sources/SwiftSyntaxBuilder/DeclSyntaxParseable.swift

@@ -31,7 +31,7 @@ public extension DeclSyntaxParseable {
     if let castedDecl = node.as(Self.self) {
       self = castedDecl
     } else {
-      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: node)
+      throw SyntaxStringInterpolationInvalidNodeTypeError(expectedType: Self.self, actualNode: node)
     }
   }
 }

Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift

@@ -161,26 +161,28 @@ where Self.StringInterpolation == SyntaxStringInterpolation {
   init(stringInterpolation: SyntaxStringInterpolation)
 }
 
-// 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))
+/// Describes an error when building a syntax node with string interpolation resulted in an unexpected node type.
+public struct SyntaxStringInterpolationInvalidNodeTypeError: Error, CustomStringConvertible {
+  let expectedType: SyntaxProtocol.Type
+  let actualType: SyntaxProtocol.Type
+
+  /// Initialize the invalid node type error providing an expected type, and the actual node that resulted.
+  public init<S: SyntaxProtocol>(expectedType: SyntaxProtocol.Type, actualNode: S) {
+    self.expectedType = expectedType
+    self.actualType = type(of: actualNode)
   }
 
   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)"
-    case .diagnostics(let diagnostics, let tree):
-      // Start the diagnostic on a new line so it isn't prefixed with the file, which messes up the
-      // column-aligned message from ``DiagnosticsFormatter``.
-      return "\n" + DiagnosticsFormatter.annotatedSource(tree: tree, diags: diagnostics)
-    }
+    return "Parsing the code snippet was expected to produce a \(expectedType) but produced a \(actualType)"
+  }
+}
+
+struct SyntaxStringInterpolationDiagnosticError: Error, CustomStringConvertible {
+  let diagnostics: [Diagnostic]
+  let tree: Syntax
+
+  var description: String {
+    return "\n" + DiagnosticsFormatter.annotatedSource(tree: tree, diags: diagnostics)
   }
 }
 

Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift

@@ -71,7 +71,7 @@ public extension HasTrailingCodeBlock where Self: StmtSyntaxProtocol {
   init(_ header: SyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () throws -> CodeBlockItemListSyntax) throws {
     let stmt = StmtSyntax("\(header) {}")
     guard let castedStmt = stmt.as(Self.self) else {
-      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: stmt)
+      throw SyntaxStringInterpolationInvalidNodeTypeError(expectedType: Self.self, actualNode: stmt)
     }
     self = castedStmt
     self.body = try CodeBlockSyntax(statements: bodyBuilder())
@@ -121,7 +121,7 @@ public extension HasTrailingOptionalCodeBlock where Self: DeclSyntaxProtocol {
   init(_ header: SyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () throws -> CodeBlockItemListSyntax) throws {
     let decl = DeclSyntax("\(header) {}")
     guard let castedDecl = decl.as(Self.self) else {
-      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: decl)
+      throw SyntaxStringInterpolationInvalidNodeTypeError(expectedType: Self.self, actualNode: decl)
     }
     self = castedDecl
     self.body = try CodeBlockSyntax(statements: bodyBuilder())
@@ -166,7 +166,7 @@ public extension HasTrailingMemberDeclBlock where Self: DeclSyntaxProtocol {
   init(_ header: SyntaxNodeString, @MemberBlockItemListBuilder membersBuilder: () throws -> MemberBlockItemListSyntax) throws {
     let decl = DeclSyntax("\(header) {}")
     guard let castedDecl = decl.as(Self.self) else {
-      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: decl)
+      throw SyntaxStringInterpolationInvalidNodeTypeError(expectedType: Self.self, actualNode: decl)
     }
     self = castedDecl
     self.memberBlock = try MemberBlockSyntax(members: membersBuilder())
@@ -209,7 +209,7 @@ public extension IfExprSyntax {
   ) throws {
     let expr = ExprSyntax("\(header) {}")
     guard let ifExpr = expr.as(Self.self) else {
-      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: expr)
+      throw SyntaxStringInterpolationInvalidNodeTypeError(expectedType: Self.self, actualNode: expr)
     }
     self = ifExpr
     self.body = try CodeBlockSyntax(statements: bodyBuilder())
@@ -254,7 +254,7 @@ public extension IfExprSyntax {
   init(_ header: SyntaxNodeString, @CodeBlockItemListBuilder bodyBuilder: () throws -> CodeBlockItemListSyntax, elseIf: IfExprSyntax) throws {
     let expr = ExprSyntax("\(header) {}")
     guard let ifExpr = expr.as(Self.self) else {
-      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: expr)
+      throw SyntaxStringInterpolationInvalidNodeTypeError(expectedType: Self.self, actualNode: expr)
     }
     self = ifExpr
     self.body = CodeBlockSyntax(statements: try bodyBuilder())
@@ -321,7 +321,7 @@ public extension SwitchExprSyntax {
   init(_ header: SyntaxNodeString, @SwitchCaseListBuilder casesBuilder: () throws -> SwitchCaseListSyntax = { SwitchCaseListSyntax([]) }) throws {
     let expr = ExprSyntax("\(header) {}")
     guard let switchExpr = expr.as(Self.self) else {
-      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: expr)
+      throw SyntaxStringInterpolationInvalidNodeTypeError(expectedType: Self.self, actualNode: expr)
     }
     self = switchExpr
     self.cases = try casesBuilder()
@@ -355,7 +355,7 @@ public extension VariableDeclSyntax {
   init(_ header: SyntaxNodeString, @CodeBlockItemListBuilder accessor: () throws -> CodeBlockItemListSyntax) throws {
     let decl = DeclSyntax("\(header) {}")
     guard let castedDecl = decl.as(Self.self) else {
-      throw SyntaxStringInterpolationError.producedInvalidNodeType(expectedType: Self.self, actualNode: decl)
+      throw SyntaxStringInterpolationInvalidNodeTypeError(expectedType: Self.self, actualNode: decl)
     }
     self = castedDecl
     precondition(self.bindings.count == 1)

Sources/SwiftSyntaxBuilder/ValidatingSyntaxNodes.swift

@@ -25,7 +25,7 @@ extension SyntaxProtocol {
     if node.hasError {
       let diagnostics = ParseDiagnosticsGenerator.diagnostics(for: node)
       precondition(!diagnostics.isEmpty)
-      throw SyntaxStringInterpolationError.diagnostics(diagnostics, tree: Syntax(node))
+      throw SyntaxStringInterpolationDiagnosticError(diagnostics: diagnostics, tree: Syntax(node))
     }
     self = node
   }
@@ -52,7 +52,7 @@ extension Trivia {
         }
         offset += piece.sourceLength.utf8Length
       }
-      throw SyntaxStringInterpolationError.diagnostics(diagnostics, tree: Syntax(tree))
+      throw SyntaxStringInterpolationDiagnosticError(diagnostics: diagnostics, tree: Syntax(tree))
     }
   }
 }

Sources/SwiftSyntaxMacros/MacroExpansionContext.swift

@@ -86,7 +86,7 @@ extension MacroExpansionContext {
       diagnostics = diagnosticsError.diagnostics
     } else if let message = error as? DiagnosticMessage {
       diagnostics = [Diagnostic(node: Syntax(node), message: message)]
-    } else if let error = error as? SyntaxStringInterpolationError {
+    } else if let error = error as? SyntaxStringInterpolationInvalidNodeTypeError {
       let diagnostic = Diagnostic(node: Syntax(node), message: ThrownErrorDiagnostic(message: "Internal macro error: \(error.description)"))
       diagnostics = [diagnostic]
     } else {

Tests/SwiftSyntaxMacroExpansionTest/MacroExpansionContextTests.swift

@@ -12,7 +12,7 @@
 
 import SwiftDiagnostics
 import SwiftSyntax
-@_spi(Diagnostics) import SwiftSyntaxBuilder
+import SwiftSyntaxBuilder
 import SwiftSyntaxMacroExpansion
 import SwiftSyntaxMacros
 import SwiftSyntaxMacrosTestSupport
@@ -44,10 +44,10 @@ 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"))
+    let error = SyntaxStringInterpolationInvalidNodeTypeError(expectedType: DeclSyntax.self, actualNode: ExprSyntax("test"))
 
+    // 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:"))
   }