Simplify treatment of single-token lookahead in Scanner

No need to start a separate scanner; we can simply use the existing prev/next logic.

Author: odersky

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -206,7 +206,9 @@ object Parsers {
     def isBindingIntro: Boolean = {
       in.token match {
         case USCORE => true
-        case IDENTIFIER | BACKQUOTED_IDENT => in.lookaheadIn(BitSet(ARROW, CTXARROW))
+        case IDENTIFIER | BACKQUOTED_IDENT =>
+          val nxt = in.lookahead.token
+          nxt == ARROW || nxt == CTXARROW
         case LPAREN =>
           val lookahead = in.LookaheadScanner()
           lookahead.skipParens()
@@ -235,7 +237,7 @@ object Parsers {
      */
     def isSplice: Boolean =
       in.token == IDENTIFIER && in.name(0) == '$' && {
-        if (in.name.length == 1) in.lookaheadIn(BitSet(LBRACE))
+        if in.name.length == 1 then in.lookahead.token == LBRACE
         else (staged & StageKind.Quoted) != 0
       }
 
@@ -1506,7 +1508,10 @@ object Parsers {
 
     /** Is current ident a `*`, and is it followed by a `)` or `,`? */
     def isPostfixStar: Boolean =
-      in.name == nme.raw.STAR && in.lookaheadIn(BitSet(RPAREN, COMMA))
+      in.name == nme.raw.STAR && {
+        val nxt = in.lookahead.token
+        nxt == RPAREN || nxt == COMMA
+      }
 
     def infixTypeRest(t: Tree): Tree =
       infixOps(t, canStartTypeTokens, refinedType, isType = true, isOperator = !isPostfixStar)
@@ -1588,11 +1593,10 @@ object Parsers {
       else if (in.token == LBRACE)
         atSpan(in.offset) { RefinedTypeTree(EmptyTree, refinement()) }
       else if (isSimpleLiteral) { SingletonTypeTree(literal(inType = true)) }
-      else if (isIdent(nme.raw.MINUS) && in.lookaheadIn(numericLitTokens)) {
+      else if isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token) then
         val start = in.offset
         in.nextToken()
         SingletonTypeTree(literal(negOffset = start, inType = true))
-      }
       else if (in.token == USCORE) {
         if sourceVersion.isAtLeast(`3.1`) then
           deprecationWarning(em"`_` is deprecated for wildcard arguments of types: use `?` instead")
@@ -2012,7 +2016,7 @@ object Parsers {
       case _ =>
         if isIdent(nme.inline)
            && !in.inModifierPosition()
-           && in.lookaheadIn(in.canStartExprTokens)
+           && in.canStartExprTokens.contains(in.lookahead.token)
         then
           val start = in.skipToken()
           in.token match
@@ -3005,7 +3009,7 @@ object Parsers {
               val isParams =
                 !impliedMods.is(Given)
                 || startParamTokens.contains(in.token)
-                || isIdent && (in.name == nme.inline || in.lookaheadIn(BitSet(COLON)))
+                || isIdent && (in.name == nme.inline || in.lookahead.token == COLON)
               if isParams then commaSeparated(() => param())
               else contextTypes(ofClass, nparams)
           checkVarArgsRules(clause)
@@ -3567,7 +3571,7 @@ object Parsers {
         val tparams = typeParamClauseOpt(ParamOwner.Def)
         newLineOpt()
         val vparamss =
-          if in.token == LPAREN && in.lookaheadIn(nme.using)
+          if in.token == LPAREN && in.lookahead.isIdent(nme.using)
           then paramClauses(givenOnly = true)
           else Nil
         newLinesOpt()

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -98,6 +98,13 @@ object Scanners {
       this.strVal = td.strVal
       this.base = td.base
     }
+
+    def isNewLine = token == NEWLINE || token == NEWLINES
+    def isIdent = token == IDENTIFIER || token == BACKQUOTED_IDENT
+    def isIdent(name: Name) = token == IDENTIFIER && this.name == name
+
+    def isNestedStart = token == LBRACE || token == INDENT
+    def isNestedEnd = token == RBRACE || token == OUTDENT
   }
 
   abstract class ScannerCommon(source: SourceFile)(implicit ctx: Context) extends CharArrayReader with TokenData {
@@ -535,7 +542,7 @@ object Scanners {
 
     def observeColonEOL(): Unit =
       if token == COLON then
-        lookahead()
+        lookAhead()
         val atEOL = isAfterLineEnd || token == EOF
         reset()
         if atEOL then token = COLONEOL
@@ -562,7 +569,7 @@ object Scanners {
         insert(OUTDENT, offset)
       case _ =>
 
-    def lookahead() = {
+    def lookAhead() = {
       prev.copyFrom(this)
       lastOffset = lastCharOffset
       fetchToken()
@@ -591,12 +598,12 @@ object Scanners {
       }
       token match {
         case CASE =>
-          lookahead()
+          lookAhead()
           if (token == CLASS) fuse(CASECLASS)
           else if (token == OBJECT) fuse(CASEOBJECT)
           else reset()
         case SEMI =>
-          lookahead()
+          lookAhead()
           if (token != ELSE) reset()
         case COMMA =>
           def isEnclosedInParens(r: Region): Boolean = r match
@@ -608,7 +615,7 @@ object Scanners {
               insert(OUTDENT, offset)
               currentRegion = r.outer
             case _ =>
-              lookahead()
+              lookAhead()
               if isAfterLineEnd
                  && (token == RPAREN || token == RBRACKET || token == RBRACE || token == OUTDENT)
               then
@@ -892,6 +899,15 @@ object Scanners {
 
 // Lookahead ---------------------------------------------------------------
 
+    /** The next token after this one.
+     *  Newlines and indent/unindent tokens are skipped.
+     */
+     def lookahead: TokenData =
+      if next.token == EMPTY then
+        lookAhead()
+        reset()
+      next
+
     class LookaheadScanner() extends Scanner(source, offset)
 
     /** Skip matching pairs of `(...)` or `[...]` parentheses.
@@ -904,17 +920,6 @@ object Scanners {
         if token == opening && multiple then skipParens() else nextToken()
       nextToken()
 
-    /** Is the token following the current one in `tokens`? */
-    def lookaheadIn(follow: BitSet | TermName): Boolean =
-      val lookahead = LookaheadScanner()
-      while
-        lookahead.nextToken()
-        lookahead.isNewLine
-      do ()
-      follow match
-        case tokens: BitSet => tokens.contains(lookahead.token)
-        case name: TermName => lookahead.token == IDENTIFIER && lookahead.name == name
-
     /** Is the current token in a position where a modifier is allowed? */
     def inModifierPosition(): Boolean = {
       val lookahead = LookaheadScanner()
@@ -1010,14 +1015,7 @@ object Scanners {
       isSoftModifier && inModifierPosition()
 
     def isSoftModifierInParamModifierPosition: Boolean =
-      isSoftModifier && !lookaheadIn(BitSet(COLON))
-
-    def isNewLine = token == NEWLINE || token == NEWLINES
-    def isIdent = token == IDENTIFIER || token == BACKQUOTED_IDENT
-    def isIdent(name: Name) = token == IDENTIFIER && this.name == name
-
-    def isNestedStart = token == LBRACE || token == INDENT
-    def isNestedEnd = token == RBRACE || token == OUTDENT
+      isSoftModifier && lookahead.token != COLON
 
     def canStartStatTokens =
       if migrateTo3 then canStartStatTokens2 else canStartStatTokens3