Use a token name for diagnostics to generate diagnostic messages

Sources/SwiftParser/Diagnostics/ParserDiagnosticMessages.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 import SwiftDiagnostics
-import SwiftSyntax
+@_spi(RawSyntax) import SwiftSyntax
 
 let diagnosticDomain: String = "SwiftParser"
 
@@ -139,22 +139,27 @@ public struct MissingTokenError: ParserError {
   public let missingToken: TokenSyntax
 
   public var message: String {
-    guard let parent = missingToken.parent, let parentTypeName = parent.nodeTypeNameForDiagnostics() else {
-      return "Expected '\(missingToken.text)'"
+    var message = "Expected"
+    if missingToken.text.isEmpty {
+      message += " \(missingToken.tokenKind.decomposeToRaw().rawKind.nameForDiagnostics)"
+    } else {
+      message += " '\(missingToken.text)'"
     }
-    switch missingToken.tokenKind {
-    case .leftAngle, .leftBrace, .leftParen, .leftSquareBracket:
-      if parent.children(viewMode: .fixedUp).first?.as(TokenSyntax.self) == missingToken {
-        return "Expected '\(missingToken.text)' to start \(parentTypeName)"
-      }
-    case .rightAngle, .rightBrace, .rightParen, .rightSquareBracket:
-      if parent.children(viewMode: .fixedUp).last?.as(TokenSyntax.self) == missingToken {
-        return "Expected '\(missingToken.text)' to end \(parentTypeName)"
+    if let parent = missingToken.parent, let parentTypeName = parent.nodeTypeNameForDiagnostics() {
+      switch missingToken.tokenKind {
+      case .leftAngle, .leftBrace, .leftParen, .leftSquareBracket:
+        if parent.children(viewMode: .fixedUp).first?.as(TokenSyntax.self) == missingToken {
+          message += " to start \(parentTypeName)"
+        }
+      case .rightAngle, .rightBrace, .rightParen, .rightSquareBracket:
+        if parent.children(viewMode: .fixedUp).last?.as(TokenSyntax.self) == missingToken {
+          message += " to end \(parentTypeName)"
+        }
+      default:
+        message += " in \(parentTypeName)"
       }
-    default:
-      break
     }
-    return "Expected '\(missingToken.text)' in \(parentTypeName)"
+    return message
   }
 
   public var handledNodes: [Syntax] {

Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift

@@ -180,9 +180,9 @@ struct RawSyntaxTokenView {
   func formKind() -> TokenKind {
     switch raw.rawData.payload {
     case .parsedToken(let dat):
-      return TokenKind.fromRaw(kind: dat.tokenKind, text: dat.tokenText)
+      return TokenKind.fromRaw(kind: dat.tokenKind, text: String(syntaxText: dat.tokenText))
     case .materializedToken(let dat):
-      return TokenKind.fromRaw(kind: dat.tokenKind, text: dat.tokenText)
+      return TokenKind.fromRaw(kind: dat.tokenKind, text: String(syntaxText: dat.tokenText))
     case .layout(_):
       preconditionFailure("Must be invoked on a token")
     }

Sources/SwiftSyntax/TokenKind.swift.gyb

@@ -161,6 +161,15 @@ public enum RawTokenKind: Equatable, Hashable {
     }
   }
 
+  public var nameForDiagnostics: String {
+    switch self {
+    case .eof: return "end of file"
+% for token in SYNTAX_TOKENS:
+    case .${token.swift_kind()}: return "${token.name_for_diagnostics}"
+% end
+    }
+  }
+
   /// Returns `true` if the token is a Swift keyword.
   ///
   /// Keywords are reserved unconditionally for use by Swift and may not
@@ -222,24 +231,26 @@ for token in SYNTAX_TOKENS:
 
 extension TokenKind {
   /// If the `rawKind` has a `defaultText`, `text` can be empty.
-  static func fromRaw(kind rawKind: RawTokenKind, text: SyntaxText) -> TokenKind {
+  @_spi(RawSyntax)
+  public static func fromRaw(kind rawKind: RawTokenKind, text: String) -> TokenKind {
     switch rawKind {
     case .eof: return .eof
 % for token in SYNTAX_TOKENS:
     case .${token.swift_kind()}:
 %   if token.text:
-      assert(text.isEmpty || rawKind.defaultText == text)
+      assert(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .${token.swift_kind()}
 %   else:
-      return .${token.swift_kind()}(String(syntaxText: text))
+      return .${token.swift_kind()}(text)
 %   end
 % end
     }
   }
 
   /// Returns the `RawTokenKind` of this `TokenKind` and, if this `TokenKind`
   /// has associated text, the associated text, otherwise `nil`.
-  func decomposeToRaw() -> (rawKind: RawTokenKind, string: String?) {
+  @_spi(RawSyntax)
+  public func decomposeToRaw() -> (rawKind: RawTokenKind, string: String?) {
     switch self {
     case .eof: return (.eof, nil)
 % for token in SYNTAX_TOKENS: