Lift @_spi To TokenConsumer

When Library Evolution is enabled, this protocol requires its @_spi members to have default implementations. For one, there's not really a reasonable default implementation we could provide. For another, there's not really a way one could conform to this protocol without also having SPI access to raw tokens from the lexer. Lift the SPI restriction to the entire protocol and refactor the conformances a bit.

Author: CodaFi

Sources/SwiftParser/Lookahead.swift

@@ -20,7 +20,7 @@ extension Parser {
   /// arbitrary number of tokens ahead in the input stream. Instances of
   /// ``Lookahead`` are distinct from their parent ``Parser`` instances, so
   /// any tokens they consume will not be reflected in the parent parser.
-  public struct Lookahead: TokenConsumer {
+  public struct Lookahead {
     var lexemes: Lexer.LexemeSequence
     @_spi(RawSyntax)
     public var currentToken: Lexer.Lexeme
@@ -58,6 +58,21 @@ extension Parser {
   }
 }
 
+@_spi(RawSyntax)
+extension Parser.Lookahead: TokenConsumer {
+  /// Consumes the current token, and asserts that the kind of token that was
+  /// consumed matches the given kind.
+  ///
+  /// If the token kind did not match, this function will abort. It is useful
+  /// to insert structural invariants during parsing.
+  ///
+  /// - Parameter kind: The kind of token to consume.
+  /// - Returns: A token of the given kind.
+  public mutating func eat(_ kind: RawTokenKind) -> Token {
+    return self.consume(if: kind)!
+  }
+}
+
 extension Parser.Lookahead {
   @_spi(RawSyntax)
   public func peek() -> Lexer.Lexeme {
@@ -164,18 +179,6 @@ extension Parser.Lookahead {
     _ = self.canParseCustomAttribute()
     return
   }
-
-  /// Consumes the current token, and asserts that the kind of token that was
-  /// consumed matches the given kind.
-  ///
-  /// If the token kind did not match, this function will abort. It is useful
-  /// to insert structural invariants during parsing.
-  ///
-  /// - Parameter kind: The kind of token to consume.
-  /// - Returns: A token of the given kind.
-  public mutating func eat(_ kind: RawTokenKind) -> Token {
-    return self.consume(if: kind)!
-  }
 }
 
 extension Parser.Lookahead {

Sources/SwiftParser/Parser.swift

@@ -116,7 +116,7 @@ extension Parser {
 /// The exception to this is parser lookahead, which is allowed to skip as many
 /// tokens as needed to disambiguate a parse. However, because lookahead
 /// operates on a copy of the lexical stream, no input tokens are lost..
-public struct Parser: TokenConsumer {
+public struct Parser {
   @_spi(RawSyntax)
   public var arena: ParsingSyntaxArena
   /// A view of the sequence of lexemes in the input.
@@ -223,6 +223,9 @@ extension Parser {
 
 // MARK: Consuming Tokens
 
+@_spi(RawSyntax)
+extension Parser: TokenConsumer {}
+
 extension Parser {
   /// Consumes the current token and sets its kind to the given `TokenKind`,
   /// then advances the lexer to the next token.

Sources/SwiftParser/TokenConsumer.swift

@@ -13,10 +13,10 @@
 @_spi(RawSyntax) import SwiftSyntax
 
 /// A type that consumes  instances of `TokenSyntax`.
+@_spi(RawSyntax)
 public protocol TokenConsumer {
   associatedtype Token
   /// The current token syntax being examined by the consumer
-  @_spi(RawSyntax)
   var currentToken: Lexer.Lexeme { get }
   /// Whether the current token matches the given kind.
   mutating func consumeAnyToken() -> Token
@@ -26,7 +26,6 @@ public protocol TokenConsumer {
 
   /// Synthesize a missing token with `kind`.
   /// If `text` is not `nil`, use it for the token's text, otherwise use the token's default text.
-  @_spi(RawSyntax)
   mutating func missingToken(_ kind: RawTokenKind, text: SyntaxText?) -> Token
 
   /// Return the lexeme that will be parsed next.