Change LoopProgress.evaluate to take a TokenConsumer instead of a Lexeme

This slightly simpifies the call sides.

Author: ahoppen

Sources/SwiftParser/Attributes.swift

@@ -23,7 +23,7 @@ extension Parser {
     repeat {
       let attribute = self.parseAttribute()
       elements.append(attribute)
-    } while self.at(.atSign, .poundIfKeyword) && loopProgress.evaluate(currentToken)
+    } while self.at(.atSign, .poundIfKeyword) && loopProgress.evaluate(self)
     return RawAttributeListSyntax(elements: elements, arena: self.arena)
   }
 }
@@ -453,7 +453,7 @@ extension Parser {
 
     var elements = [RawDifferentiabilityParamSyntax]()
     var loopProgress = LoopProgressCondition()
-    while !self.at(.endOfFile, .rightParen) && loopProgress.evaluate(currentToken) {
+    while !self.at(.endOfFile, .rightParen) && loopProgress.evaluate(self) {
       guard let param = self.parseDifferentiabilityParameter() else {
         break
       }
@@ -594,7 +594,7 @@ extension Parser {
   mutating func parseObjectiveCSelector() -> RawObjCSelectorSyntax {
     var elements = [RawObjCSelectorPieceSyntax]()
     var loopProgress = LoopProgressCondition()
-    while loopProgress.evaluate(currentToken) {
+    while loopProgress.evaluate(self) {
       // Empty selector piece.
       if let colon = self.consume(if: .colon) {
         elements.append(
@@ -676,7 +676,7 @@ extension Parser {
     var elements = [RawSpecializeAttributeSpecListSyntax.Element]()
     // Parse optional "exported" and "kind" labeled parameters.
     var loopProgress = LoopProgressCondition()
-    while !self.at(.endOfFile, .rightParen, .keyword(.where)) && loopProgress.evaluate(currentToken) {
+    while !self.at(.endOfFile, .rightParen, .keyword(.where)) && loopProgress.evaluate(self) {
       switch self.at(anyIn: SpecializeParameter.self) {
       case (.target, let handle)?:
         let ident = self.eat(handle)

Sources/SwiftParser/Availability.swift

@@ -48,7 +48,7 @@ extension Parser {
             arena: self.arena
           )
         )
-      } while keepGoing != nil && availabilityArgumentProgress.evaluate(currentToken)
+      } while keepGoing != nil && availabilityArgumentProgress.evaluate(self)
     }
 
     return RawAvailabilitySpecListSyntax(elements: elements, arena: self.arena)
@@ -176,7 +176,7 @@ extension Parser {
           arena: self.arena
         )
       )
-    } while keepGoing != nil && loopProgressCondition.evaluate(currentToken)
+    } while keepGoing != nil && loopProgressCondition.evaluate(self)
     return RawAvailabilitySpecListSyntax(elements: elements, arena: self.arena)
   }
 
@@ -266,7 +266,7 @@ extension Parser {
         unexpectedTokens.append(unexpectedVersion)
       }
       keepGoing = self.consume(if: .period)
-    } while keepGoing != nil && loopProgress.evaluate(currentToken)
+    } while keepGoing != nil && loopProgress.evaluate(self)
     return RawUnexpectedNodesSyntax(unexpectedTokens, arena: self.arena)
   }
 

Sources/SwiftParser/Declarations.swift

@@ -61,7 +61,7 @@ extension TokenConsumer {
 
     var hasAttribute = false
     var attributeProgress = LoopProgressCondition()
-    while attributeProgress.evaluate(subparser.currentToken) && subparser.at(.atSign) {
+    while attributeProgress.evaluate(subparser) && subparser.at(.atSign) {
       hasAttribute = true
       _ = subparser.consumeAttributeList()
     }
@@ -71,7 +71,7 @@ extension TokenConsumer {
       var modifierProgress = LoopProgressCondition()
       while let (modifierKind, handle) = subparser.at(anyIn: DeclarationModifier.self),
         modifierKind != .class,
-        modifierProgress.evaluate(subparser.currentToken)
+        modifierProgress.evaluate(subparser)
       {
         hasModifier = true
         subparser.eat(handle)
@@ -356,7 +356,7 @@ extension Parser {
           arena: self.arena
         )
       )
-    } while keepGoing != nil && loopProgress.evaluate(currentToken)
+    } while keepGoing != nil && loopProgress.evaluate(self)
     return RawImportPathSyntax(elements: elements, arena: self.arena)
   }
 }
@@ -508,7 +508,7 @@ extension Parser {
             arena: self.arena
           )
         )
-      } while keepGoing != nil && loopProgress.evaluate(currentToken)
+      } while keepGoing != nil && loopProgress.evaluate(self)
     }
 
     let whereClause: RawGenericWhereClauseSyntax?
@@ -719,7 +719,7 @@ extension Parser {
             arena: self.arena
           )
         )
-      } while keepGoing != nil && loopProgress.evaluate(currentToken)
+      } while keepGoing != nil && loopProgress.evaluate(self)
     }
 
     return RawGenericWhereClauseSyntax(
@@ -776,7 +776,7 @@ extension Parser {
     let (unexpectedBeforeLBrace, lbrace) = self.expect(.leftBrace)
     do {
       var loopProgress = LoopProgressCondition()
-      while !self.at(.endOfFile, .rightBrace) && loopProgress.evaluate(currentToken) {
+      while !self.at(.endOfFile, .rightBrace) && loopProgress.evaluate(self) {
         let newItemAtStartOfLine = self.currentToken.isAtStartOfLine
         guard let newElement = self.parseMemberDeclListItem() else {
           break
@@ -876,7 +876,7 @@ extension Parser {
             arena: self.arena
           )
         )
-      } while keepGoing != nil && loopProgress.evaluate(currentToken)
+      } while keepGoing != nil && loopProgress.evaluate(self)
     }
 
     return RawEnumCaseDeclSyntax(
@@ -1394,7 +1394,7 @@ extension Parser {
             arena: self.arena
           )
         )
-      } while keepGoing != nil && loopProgress.evaluate(currentToken)
+      } while keepGoing != nil && loopProgress.evaluate(self)
     }
 
     return RawVariableDeclSyntax(
@@ -1539,7 +1539,7 @@ extension Parser {
     var elements = [RawAccessorDeclSyntax]()
     do {
       var loopProgress = LoopProgressCondition()
-      while !self.at(.endOfFile, .rightBrace) && loopProgress.evaluate(currentToken) {
+      while !self.at(.endOfFile, .rightBrace) && loopProgress.evaluate(self) {
         guard let introducer = self.parseAccessorIntroducer() else {
           // There can only be an implicit getter if no other accessors were
           // seen before this one.
@@ -1759,7 +1759,7 @@ extension Parser {
     while (identifiersAfterOperatorName.last ?? name).trailingTriviaByteLength == 0,
       self.currentToken.leadingTriviaByteLength == 0,
       !self.at(.colon, .leftBrace, .endOfFile),
-      loopProgress.evaluate(self.currentToken)
+      loopProgress.evaluate(self)
     {
       identifiersAfterOperatorName.append(consumeAnyToken())
     }
@@ -1906,7 +1906,7 @@ extension Parser {
     var elements = [RawPrecedenceGroupAttributeListSyntax.Element]()
     do {
       var attributesProgress = LoopProgressCondition()
-      LOOP: while !self.at(.endOfFile, .rightBrace) && attributesProgress.evaluate(currentToken) {
+      LOOP: while !self.at(.endOfFile, .rightBrace) && attributesProgress.evaluate(self) {
         switch self.at(anyIn: LabelText.self) {
         case (.associativity, let handle)?:
           let associativity = self.eat(handle)
@@ -1970,7 +1970,7 @@ extension Parser {
                   arena: self.arena
                 )
               )
-            } while keepGoing != nil && namesProgress.evaluate(currentToken)
+            } while keepGoing != nil && namesProgress.evaluate(self)
           }
           elements.append(
             .precedenceGroupRelation(

Sources/SwiftParser/Directives.swift

@@ -121,7 +121,7 @@ extension Parser {
 
     // Proceed to parse #if continuation clauses (#elseif, #else, check #elif typo, #endif)
     var loopProgress = LoopProgressCondition()
-    LOOP: while let (match, handle) = self.canRecoverTo(anyIn: IfConfigContinuationClauseStartKeyword.self), loopProgress.evaluate(self.currentToken) {
+    LOOP: while let (match, handle) = self.canRecoverTo(anyIn: IfConfigContinuationClauseStartKeyword.self), loopProgress.evaluate(self) {
       var unexpectedBeforePoundKeyword: RawUnexpectedNodesSyntax?
       var poundKeyword: RawTokenSyntax
       let condition: RawExprSyntax?
@@ -208,7 +208,7 @@ extension Parser {
     while !self.at(.endOfFile)
       && !self.at(.poundElseKeyword, .poundElseifKeyword, .poundEndifKeyword)
       && !self.atElifTypo()
-      && elementsProgress.evaluate(currentToken)
+      && elementsProgress.evaluate(self)
     {
       let newItemAtStartOfLine = self.currentToken.isAtStartOfLine
       guard let element = parseElement(&self, elements.isEmpty), !element.isEmpty else {

Sources/SwiftParser/Expressions.swift

@@ -151,7 +151,7 @@ extension Parser {
     )
 
     var loopCondition = LoopProgressCondition()
-    while loopCondition.evaluate(currentToken) {
+    while loopCondition.evaluate(self) {
       guard
         !lastElement.is(RawMissingExprSyntax.self),
         !(forDirective && self.currentToken.isAtStartOfLine)
@@ -806,7 +806,7 @@ extension Parser {
     // Handle suffix expressions.
     var leadingExpr = start
     var loopCondition = LoopProgressCondition()
-    while loopCondition.evaluate(currentToken) {
+    while loopCondition.evaluate(self) {
       if forDirective && self.currentToken.isAtStartOfLine {
         return leadingExpr
       }
@@ -963,7 +963,7 @@ extension Parser {
             while !backtrack.at(.endOfFile) && !backtrack.currentToken.isAtStartOfLine {
               backtrack.skipSingle()
             }
-          } while backtrack.at(.poundIfKeyword) && loopProgress.evaluate(backtrack.currentToken)
+          } while backtrack.at(.poundIfKeyword) && loopProgress.evaluate(backtrack)
 
           guard backtrack.isAtStartOfPostfixExprSuffix() else {
             break
@@ -1086,7 +1086,7 @@ extension Parser {
 
     var components: [RawKeyPathComponentSyntax] = []
     var loopCondition = LoopProgressCondition()
-    while loopCondition.evaluate(currentToken) {
+    while loopCondition.evaluate(self) {
       // Check for a [] or .[] suffix. The latter is only permitted when there
       // are no components.
       if self.at(TokenSpec(.leftSquare, allowAtStartOfLine: false))
@@ -1692,7 +1692,7 @@ extension Parser {
     var elements = [RawSyntax]()
     do {
       var collectionLoopCondition = LoopProgressCondition()
-      COLLECTION_LOOP: while collectionLoopCondition.evaluate(currentToken) {
+      COLLECTION_LOOP: while collectionLoopCondition.evaluate(self) {
         elementKind = self.parseCollectionElement(elementKind)
 
         // Parse the ',' if exists.
@@ -1936,7 +1936,7 @@ extension Parser {
               arena: self.arena
             )
           )
-        } while keepGoing != nil && loopProgress.evaluate(currentToken)
+        } while keepGoing != nil && loopProgress.evaluate(self)
       }
       // We were promised a right square bracket, so we're going to get it.
       var unexpectedNodes = [RawSyntax]()
@@ -1991,7 +1991,7 @@ extension Parser {
                 arena: self.arena
               )
             )
-          } while keepGoing != nil && loopProgress.evaluate(currentToken)
+          } while keepGoing != nil && loopProgress.evaluate(self)
         }
 
         parameterClause = .simpleInput(RawClosureParamListSyntax(elements: params, arena: self.arena))
@@ -2130,7 +2130,7 @@ extension Parser {
           arena: self.arena
         )
       )
-    } while keepGoing != nil && loopProgress.evaluate(currentToken)
+    } while keepGoing != nil && loopProgress.evaluate(self)
     return result
   }
 }
@@ -2151,7 +2151,7 @@ extension Parser {
     // Parse labeled trailing closures.
     var elements = [RawMultipleTrailingClosureElementSyntax]()
     var loopProgress = LoopProgressCondition()
-    while self.withLookahead({ $0.isStartOfLabelledTrailingClosure() }) && loopProgress.evaluate(currentToken) {
+    while self.withLookahead({ $0.isStartOfLabelledTrailingClosure() }) && loopProgress.evaluate(self) {
       let (unexpectedBeforeLabel, label) = self.parseArgumentLabel()
       let (unexpectedBeforeColon, colon) = self.expect(.colon)
       let closure = self.parseClosureExpression()
@@ -2248,7 +2248,7 @@ extension Parser.Lookahead {
     var loopProgress = LoopProgressCondition()
     while !backtrack.at(.endOfFile, .rightBrace)
       && !backtrack.at(.poundEndifKeyword, .poundElseKeyword, .poundElseifKeyword)
-      && loopProgress.evaluate(backtrack.currentToken)
+      && loopProgress.evaluate(backtrack)
     {
       backtrack.skipSingle()
     }
@@ -2400,7 +2400,7 @@ extension Parser {
     var elements = [RawSwitchCaseListSyntax.Element]()
     var elementsProgress = LoopProgressCondition()
     while !self.at(.endOfFile, .rightBrace) && !self.at(.poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword)
-      && elementsProgress.evaluate(currentToken)
+      && elementsProgress.evaluate(self)
     {
       if self.withLookahead({ $0.isAtStartOfSwitchCase(allowRecovery: false) }) {
         elements.append(.switchCase(self.parseSwitchCase()))
@@ -2564,7 +2564,7 @@ extension Parser {
             arena: self.arena
           )
         )
-      } while keepGoing != nil && loopProgress.evaluate(currentToken)
+      } while keepGoing != nil && loopProgress.evaluate(self)
     }
     let (unexpectedBeforeColon, colon) = self.expect(.colon)
     return RawSwitchCaseLabelSyntax(
@@ -2677,7 +2677,7 @@ extension Parser.Lookahead {
   mutating func consumeEffectsSpecifiers() {
     var loopProgress = LoopProgressCondition()
     while let (_, handle) = self.at(anyIn: EffectSpecifier.self),
-      loopProgress.evaluate(currentToken)
+      loopProgress.evaluate(self)
     {
       self.eat(handle)
     }
@@ -2687,7 +2687,7 @@ extension Parser.Lookahead {
     // Consume attributes.
     var lookahead = self.lookahead()
     var attributesProgress = LoopProgressCondition()
-    while let _ = lookahead.consume(if: .atSign), attributesProgress.evaluate(lookahead.currentToken) {
+    while let _ = lookahead.consume(if: .atSign), attributesProgress.evaluate(lookahead) {
       guard lookahead.at(.identifier) else {
         break
       }
@@ -2707,7 +2707,7 @@ extension Parser.Lookahead {
 
       // While we don't have '->' or ')', eat balanced tokens.
       var skipProgress = LoopProgressCondition()
-      while !lookahead.at(.endOfFile, .rightParen) && skipProgress.evaluate(lookahead.currentToken) {
+      while !lookahead.at(.endOfFile, .rightParen) && skipProgress.evaluate(lookahead) {
         lookahead.skipSingle()
       }
 
@@ -2730,7 +2730,7 @@ extension Parser.Lookahead {
       lookahead.consumeAnyToken()
 
       var parametersProgress = LoopProgressCondition()
-      while lookahead.consume(if: .comma) != nil && parametersProgress.evaluate(lookahead.currentToken) {
+      while lookahead.consume(if: .comma) != nil && parametersProgress.evaluate(lookahead) {
         if lookahead.at(.identifier) || lookahead.at(.wildcard) {
           lookahead.consumeAnyToken()
           continue

Sources/SwiftParser/Lookahead.swift

@@ -222,7 +222,7 @@ extension Parser.Lookahead {
       self.skipUntilEndOfLine()
 
       var attributesLoopProgress = LoopProgressCondition()
-      ATTRIBUTE_LOOP: while attributesLoopProgress.evaluate(self.currentToken) {
+      ATTRIBUTE_LOOP: while attributesLoopProgress.evaluate(self) {
         switch self.currentToken.rawTokenKind {
         case .atSign:
           didSeeAnyAttributes = true
@@ -233,7 +233,7 @@ extension Parser.Lookahead {
           break ATTRIBUTE_LOOP
         }
       }
-    } while self.at(.poundElseifKeyword, .poundElseKeyword) && poundIfLoopProgress.evaluate(self.currentToken)
+    } while self.at(.poundElseifKeyword, .poundElseKeyword) && poundIfLoopProgress.evaluate(self)
 
     return didSeeAnyAttributes && self.currentToken.isAtStartOfLine && self.consume(if: .poundEndifKeyword) != nil
   }

Sources/SwiftParser/LoopProgressCondition.swift

@@ -20,11 +20,25 @@ struct LoopProgressCondition {
   init() {}
 
   /// Check that the loop has made progress since `evaluate` was called the last time.
-  /// `currentToken` is the current token of the parser.
   /// In assert builds, this traps if the loop has not made any parser progress in between two iterations,
   /// ie. it checks if the parser's `currentToken` has changed in between two calls to `evaluate`.
   /// In non-assert builds, `evaluate()` returns `false` if the loop has not made progress, thus aborting the loop.
-  mutating func evaluate(_ currentToken: Lexer.Lexeme) -> Bool {
+  @inline(__always)
+  mutating func evaluate(_ parser: Parser) -> Bool {
+    return evaluate(parser.currentToken)
+  }
+
+  /// Check that the loop has made progress since `evaluate` was called the last time.
+  /// In assert builds, this traps if the loop has not made any parser progress in between two iterations,
+  /// ie. it checks if the parser's `currentToken` has changed in between two calls to `evaluate`.
+  /// In non-assert builds, `evaluate()` returns `false` if the loop has not made progress, thus aborting the loop.
+  @inline(__always)
+  mutating func evaluate(_ parser: Parser.Lookahead) -> Bool {
+    return evaluate(parser.currentToken)
+  }
+
+  /// Implementation of the above `evaluate` methods.
+  private mutating func evaluate(_ currentToken: Lexer.Lexeme) -> Bool {
     defer {
       self.currentToken = currentToken
     }

Sources/SwiftParser/Modifiers.swift

@@ -16,7 +16,7 @@ extension Parser {
   mutating func parseModifierList() -> RawModifierListSyntax? {
     var elements = [RawDeclModifierSyntax]()
     var modifierLoopCondition = LoopProgressCondition()
-    MODIFIER_LOOP: while modifierLoopCondition.evaluate(currentToken) {
+    MODIFIER_LOOP: while modifierLoopCondition.evaluate(self) {
       switch self.canRecoverTo(anyIn: DeclarationStart.self) {
       case (.declarationModifier(.private), _)?,
         (.declarationModifier(.fileprivate), _)?,