Make RawTokenSyntax RawSyntax SPI

I has been a bit incosistent that something named `Raw` was part of SwiftSyntax’s public API. Put it behind `RawSyntax` SPI for now. If we want to make it public again, we should rename it to something that doesn’t contain `Raw`

Author: ahoppen

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/TokenSpecStaticMembersFile.swift

@@ -16,7 +16,7 @@ import SyntaxSupport
 import Utils
 
 let tokenSpecStaticMembersFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
-  DeclSyntax("import SwiftSyntax")
+  DeclSyntax("@_spi(RawSyntax) import SwiftSyntax")
 
   try! ExtensionDeclSyntax("extension TokenSpec") {
     DeclSyntax("static var eof: TokenSpec { return TokenSpec(.eof) }")

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TokenKindFile.swift

@@ -153,6 +153,7 @@ let tokenKindFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     // `RawTokenBaseKind` for equality. With the raw value, it compiles down to
     // a primitive integer compare, without, it calls into `__derived_enum_equals`.
     @frozen // FIXME: Not actually stable, works around a miscompile
+    @_spi(RawSyntax)
     public enum RawTokenKind: UInt8, Equatable, Hashable
     """
   ) {

Sources/SwiftParser/Lookahead.swift

@@ -90,6 +90,7 @@ extension Parser.Lookahead {
     self.currentToken = self.lexemes.advance()
   }
 
+  @_spi(RawSyntax)
   public mutating func consumeAnyToken(remapping: RawTokenKind) {
     self.consumeAnyToken()
   }

Sources/SwiftParser/TokenPrecedence.swift

@@ -15,7 +15,7 @@
 /// Describes how distinctive a token is for parser recovery. When expecting a
 /// token, tokens with a lower token precedence may be skipped and considered
 /// unexpected.
-public enum TokenPrecedence: Comparable {
+enum TokenPrecedence: Comparable {
   /// An unknown token. This is known garbage and should always be allowed to be skipped.
   case unknownToken
   /// Tokens that can be used similar to variable names or literals

Sources/SwiftParser/TokenSpec.swift

@@ -137,7 +137,7 @@ struct TokenSpec {
   @inline(__always)
   static func ~= (kind: TokenSpec, token: TokenSyntax) -> Bool {
     return kind.matches(
-      rawTokenKind: token.rawTokenKind,
+      rawTokenKind: token.tokenView.rawKind,
       keyword: Keyword(token.tokenView.rawText),
       atStartOfLine: token.leadingTrivia.contains(where: { $0.isNewline })
     )

Sources/SwiftParser/generated/TokenSpecStaticMembers.swift

@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import SwiftSyntax
+@_spi(RawSyntax) import SwiftSyntax
 
 extension TokenSpec {
   static var eof: TokenSpec { 

Sources/SwiftParserDiagnostics/MissingTokenError.swift

@@ -27,7 +27,7 @@ extension ParseDiagnosticsGenerator {
     // this token.
 
     let handled: Bool
-    switch (missingToken.rawTokenKind, invalidToken.rawTokenKind) {
+    switch (missingToken.tokenView.rawKind, invalidToken.tokenView.rawKind) {
     case (.identifier, _):
       handled = handleInvalidIdentifier(invalidToken: invalidToken, missingToken: missingToken, invalidTokenContainer: invalidTokenContainer)
     case (.multilineStringQuote, .multilineStringQuote):
@@ -103,7 +103,7 @@ extension ParseDiagnosticsGenerator {
     ]
 
     if let identifier = missingToken.nextToken(viewMode: .all),
-      identifier.rawTokenKind == .identifier,
+      identifier.tokenView.rawKind == .identifier,
       identifier.presence == .missing
     {
       // The extraneous whitespace caused a missing identifier, output a

Sources/SwiftSyntax/TokenSyntax.swift

@@ -68,10 +68,6 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
     return tokenKind.text
   }
 
-  public var rawTokenKind: RawTokenKind {
-    return tokenView.rawKind
-  }
-
   /// Returns a new TokenSyntax with its kind replaced
   /// by the provided token kind.
   public func withKind(_ tokenKind: TokenKind) -> TokenSyntax {

Sources/SwiftSyntax/generated/TokenKind.swift

@@ -474,6 +474,7 @@ extension TokenKind: Equatable {
 // `RawTokenBaseKind` for equality. With the raw value, it compiles down to
 // a primitive integer compare, without, it calls into `__derived_enum_equals`.
 @frozen // FIXME: Not actually stable, works around a miscompile
+@_spi(RawSyntax)
 public enum RawTokenKind: UInt8, Equatable, Hashable {
   case eof
   case arrow

Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift

@@ -283,7 +283,7 @@ extension StringLiteralExprSyntax {
       }
     }
 
-    let escapedContent = content.escapingForStringLiteral(usingDelimiter: closeDelimiter?.text ?? "", isMultiline: openQuote.rawTokenKind == .multilineStringQuote)
+    let escapedContent = content.escapingForStringLiteral(usingDelimiter: closeDelimiter?.text ?? "", isMultiline: openQuote.tokenView.rawKind == .multilineStringQuote)
     let contentToken = TokenSyntax.stringSegment(escapedContent)
     let segment = StringSegmentSyntax(content: contentToken)
     let segments = StringLiteralSegmentsSyntax([.stringSegment(segment)])