refactor: introduce lookaheadInLineCharCode

packages/babel-parser/src/parser/expression.ts

@@ -1287,8 +1287,7 @@ export default abstract class ExpressionParser extends LValParser {
         if (tokenIsIdentifier(type)) {
           if (
             this.isContextual(tt._module) &&
-            this.lookaheadCharCode() === charCodes.leftCurlyBrace &&
-            !this.hasFollowingLineBreak()
+            this.lookaheadInLineCharCode() === charCodes.leftCurlyBrace
           ) {
             return this.parseModuleExpression();
           }

packages/babel-parser/src/parser/statement.ts

@@ -329,20 +329,21 @@ export default abstract class StatementParser extends ExpressionParser {
 
   /**
    * Assuming we have seen a contextual `using` and declaration is allowed, check if it
-   * starts a variable declaration so that it should be interpreted as a keyword.
+   * starts a variable declaration in the same line so that it should be interpreted as
+   * a keyword.
    */
-  hasFollowingBindingIdentifier(): boolean {
-    const next = this.nextTokenStart();
+  hasInLineFollowingBindingIdentifier(): boolean {
+    const next = this.nextTokenInLineStart();
     const nextCh = this.codePointAtPos(next);
     return this.chStartsBindingIdentifier(nextCh, next);
   }
 
   startsUsingForOf(): boolean {
-    const lookahead = this.lookahead();
-    if (lookahead.type === tt._of && !lookahead.containsEsc) {
+    const { type, containsEsc } = this.lookahead();
+    if (type === tt._of && !containsEsc) {
       // `using of` must start a for-lhs-of statement
       return false;
-    } else {
+    } else if (tokenIsIdentifier(type) && !this.hasFollowingLineBreak()) {
       this.expectPlugin("explicitResourceManagement");
       return true;
     }
@@ -485,9 +486,8 @@ export default abstract class StatementParser extends ExpressionParser {
       case tt._using:
         // using [no LineTerminator here][lookahead != `await`] BindingList[+Using]
         if (
-          this.hasFollowingLineBreak() ||
           this.state.containsEsc ||
-          !this.hasFollowingBindingIdentifier()
+          !this.hasInLineFollowingBindingIdentifier()
         ) {
           break;
         }
@@ -913,13 +913,10 @@ export default abstract class StatementParser extends ExpressionParser {
     }
 
     const startsWithLet = this.isContextual(tt._let);
-    const startsWithUsing =
-      this.isContextual(tt._using) && !this.hasFollowingLineBreak();
+    const startsWithUsing = this.isContextual(tt._using);
     const isLetOrUsing =
       (startsWithLet && this.hasFollowingBindingAtom()) ||
-      (startsWithUsing &&
-        this.hasFollowingBindingIdentifier() &&
-        this.startsUsingForOf());
+      (startsWithUsing && this.startsUsingForOf());
     if (this.match(tt._var) || this.match(tt._const) || isLetOrUsing) {
       const initNode = this.startNode<N.VariableDeclaration>();
       const kind = this.state.value;

packages/babel-parser/src/tokenizer/index.ts

@@ -29,6 +29,7 @@ import {
   isNewLine,
   isWhitespace,
   skipWhiteSpace,
+  skipWhiteSpaceInLine,
 } from "../util/whitespace";
 import State from "./state";
 import type { LookaheadState, DeferredStrictError } from "./state";
@@ -195,6 +196,34 @@ export default abstract class Tokenizer extends CommentsParser {
     return this.input.charCodeAt(this.nextTokenStart());
   }
 
+  /**
+   * Similar to nextToken, but it will stop at line break when it is seen before the next token
+   *
+   * @returns {number} position of the next token start or line break, whichever is seen first.
+   * @memberof Tokenizer
+   */
+  nextTokenInLineStart(): number {
+    return this.nextTokenInLineStartSince(this.state.pos);
+  }
+
+  nextTokenInLineStartSince(pos: number): number {
+    skipWhiteSpaceInLine.lastIndex = pos;
+    return skipWhiteSpaceInLine.test(this.input)
+      ? skipWhiteSpaceInLine.lastIndex
+      : pos;
+  }
+
+  /**
+   * Similar to lookaheadCharCode, but it will return the char code of line break if it is
+   * seen before the next token
+   *
+   * @returns {number} char code of the next token start or line break, whichever is seen first.
+   * @memberof Tokenizer
+   */
+  lookaheadInLineCharCode(): number {
+    return this.input.charCodeAt(this.nextTokenInLineStart());
+  }
+
   codePointAtPos(pos: number): number {
     // The implementation is based on
     // https://source.chromium.org/chromium/chromium/src/+/master:v8/src/builtins/builtins-string-gen.cc;l=1455;drc=221e331b49dfefadbc6fa40b0c68e6f97606d0b3;bpv=0;bpt=1

packages/babel-parser/src/util/whitespace.ts

@@ -22,7 +22,7 @@ export function isNewLine(code: number): boolean {
 export const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
 
 export const skipWhiteSpaceInLine =
-  /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/y;
+  /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/g;
 
 // Skip whitespace and single-line comments, including /* no newline here */.
 // After this RegExp matches, its lastIndex points to a line terminator, or