fix(all): used logical names to avoid confusions

meriyah · May 30, 2019 · 6f25b7b · 6f25b7b
1 parent 82d423d
commit 6f25b7b
Show file tree

Hide file tree

Showing 9 changed files with 285 additions and 282 deletions.
diff --git a/src/common.ts b/src/common.ts
@@ -121,9 +121,9 @@ export interface ParserState {
   index: number;
   line: number;
   column: number;
+  tokenIndex: number;
   startIndex: number;
-  lastIndex: number;
-  length: number;
+  end: number;
   token: Token;
   tokenValue: any;
   tokenRaw: string;
@@ -370,7 +370,7 @@ export function finishNode<T extends Node>(
 ): T {
   if (context & Context.OptionsRanges) {
     node.start = start;
-    node.end = parser.lastIndex;
+    node.end = parser.startIndex;
 }
 
   return node;

diff --git a/src/lexer/comments.ts b/src/lexer/comments.ts
@@ -11,15 +11,15 @@ import { report, Errors } from '../errors';
  */
 export function skipHashBang(parser: ParserState): void {
   let index = parser.index;
-  if (index === parser.length) return;
+  if (index === parser.end) return;
   if (parser.currentCodePoint === Chars.ByteOrderMark) {
     parser.currentCodePoint = parser.source.charCodeAt(++index);
     parser.index = index;
   }
 
-  if (index < parser.length && parser.source.charCodeAt(index) === Chars.Hash) {
+  if (index < parser.end && parser.source.charCodeAt(index) === Chars.Hash) {
     index++;
-    if (index < parser.length && parser.source.charCodeAt(index) === Chars.Exclamation) {
+    if (index < parser.end && parser.source.charCodeAt(index) === Chars.Exclamation) {
       parser.index = index + 1;
       parser.currentCodePoint = parser.source.charCodeAt(parser.index);
       skipSingleLineComment(parser);
@@ -35,7 +35,7 @@ export function skipHashBang(parser: ParserState): void {
  * @param parser  Parser object
  */
 export function skipSingleLineComment(parser: ParserState): Token {
-  while (parser.index < parser.length) {
+  while (parser.index < parser.end) {
     if (
       CharTypes[parser.currentCodePoint] & CharFlags.LineTerminator ||
       (parser.currentCodePoint ^ Chars.LineSeparator) <= 1
@@ -53,7 +53,7 @@ export function skipSingleLineComment(parser: ParserState): Token {
  * @param parser  Parser object
  */
 export function skipMultiLineComment(parser: ParserState): any {
-  while (parser.index < parser.length) {
+  while (parser.index < parser.end) {
     while (CharTypes[parser.currentCodePoint] & CharFlags.Asterisk) {
       if (nextCodePoint(parser) === Chars.Slash) {
         nextCodePoint(parser);

diff --git a/src/lexer/identifier.ts b/src/lexer/identifier.ts
@@ -13,7 +13,7 @@ export function scanIdentifier(parser: ParserState, context: Context): Token {
   if (parser.currentCodePoint <= 0x7e) {
     if ((CharTypes[parser.currentCodePoint] & CharFlags.BackSlash) === 0) {
       while ((CharTypes[nextCodePoint(parser)] & CharFlags.IdentifierPart) !== 0) {}
-      parser.tokenValue = parser.source.slice(parser.startIndex, parser.index);
+      parser.tokenValue = parser.source.slice(parser.tokenIndex, parser.index);
       if (parser.currentCodePoint > 0x7e) return scanIdentifierSlowCase(parser, context, hasEscape, canBeKeyword);
 
       if ((CharTypes[parser.currentCodePoint] & CharFlags.BackSlash) === 0) {
@@ -38,7 +38,7 @@ export function scanIdentifierSlowCase(
   canBeKeyword: number
 ): Token {
   let start = parser.index;
-  while (parser.index < parser.length) {
+  while (parser.index < parser.end) {
     if (CharTypes[parser.currentCodePoint] & CharFlags.BackSlash) {
       parser.tokenValue += parser.source.slice(start, parser.index);
       hasEscape = 1;
@@ -57,7 +57,7 @@ export function scanIdentifierSlowCase(
     }
   }
 
-  if (parser.index <= parser.length) {
+  if (parser.index <= parser.end) {
     parser.tokenValue += parser.source.slice(start, parser.index);
   }
 
@@ -97,7 +97,7 @@ export function scanPrivateName(parser: ParserState): Token {
 export function scanIdentifierUnicodeEscape(parser: ParserState): any {
   // Check for Unicode escape of the form '\uXXXX'
   // and return code point value if valid Unicode escape is found. Otherwise return -1.
-  if (parser.index + 5 < parser.length && parser.source.charCodeAt(parser.index + 1) === Chars.LowerU) {
+  if (parser.index + 5 < parser.end && parser.source.charCodeAt(parser.index + 1) === Chars.LowerU) {
     parser.currentCodePoint = parser.source.charCodeAt((parser.index += 2));
     return scanUnicodeEscapeValue(parser);
   }

diff --git a/src/lexer/numeric.ts b/src/lexer/numeric.ts
@@ -83,7 +83,7 @@ export function scanNumber(parser: ParserState, context: Context, isFloat: boole
         }
 
         if (digit >= 0 && parser.currentCodePoint !== Chars.Period && !isIdentifierStart(parser.currentCodePoint)) {
-          if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.startIndex, parser.index);
+          if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
           parser.tokenValue = value;
           return Token.NumericLiteral;
         }
@@ -142,15 +142,15 @@ export function scanNumber(parser: ParserState, context: Context, isFloat: boole
   if (CharTypes[parser.currentCodePoint] & CharFlags.Decimal || isIdentifierStart(parser.currentCodePoint)) {
     report(parser, Errors.IDStartAfterNumber);
   }
-  if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.startIndex, parser.index);
+  if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
   parser.tokenValue =
     kind & (NumberKind.ImplicitOctal | NumberKind.Binary | NumberKind.Hex | NumberKind.Octal)
       ? value
       : kind & NumberKind.DecimalWithLeadingZero
-      ? parseFloat(parser.source.slice(parser.startIndex, parser.index))
+      ? parseFloat(parser.source.slice(parser.tokenIndex, parser.index))
       : isBigInt
-      ? parseInt(parser.source.slice(parser.startIndex, parser.index), 0xa)
-      : +parser.source.slice(parser.startIndex, parser.index);
+      ? parseInt(parser.source.slice(parser.tokenIndex, parser.index), 0xa)
+      : +parser.source.slice(parser.tokenIndex, parser.index);
   if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.tokenValue, parser.index);
   return isBigInt ? Token.BigIntLiteral : Token.NumericLiteral;
 }
diff --git a/src/lexer/regexp.ts b/src/lexer/regexp.ts
@@ -117,7 +117,7 @@ export function scanRegularExpression(parser: ParserState, context: Context): To
 
   parser.tokenRegExp = { pattern, flags };
 
-  if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.startIndex, parser.index);
+  if (context & Context.OptionsRaw) parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
 
   parser.tokenValue = validate(parser, pattern, flags);
 

diff --git a/src/lexer/scan.ts b/src/lexer/scan.ts
@@ -164,15 +164,15 @@ export const OneCharToken = [
 
 export function nextToken(parser: ParserState, context: Context): void {
   parser.flags &= ~Flags.NewLine;
-  parser.lastIndex = parser.index;
+  parser.startIndex = parser.index;
   parser.token = scanSingleToken(parser, context);
 }
 
 export function scanSingleToken(parser: ParserState, context: Context): Token {
   let isStartOfLine = parser.index === 0;
 
-  while (parser.index < parser.length) {
-    parser.startIndex = parser.index;
+  while (parser.index < parser.end) {
+    parser.tokenIndex = parser.index;
 
     const first = parser.currentCodePoint;
 
@@ -249,7 +249,7 @@ export function scanSingleToken(parser: ParserState, context: Context): Token {
         // `*`, `**`, `*=`, `**=`
         case Token.Multiply: {
           nextCodePoint(parser);
-          if (parser.index >= parser.length) return Token.Multiply;
+          if (parser.index >= parser.end) return Token.Multiply;
           const next = parser.currentCodePoint;
 
           if (next === Chars.EqualSign) {
@@ -273,7 +273,7 @@ export function scanSingleToken(parser: ParserState, context: Context): Token {
         // `+`, `++`, `+=`
         case Token.Add: {
           nextCodePoint(parser);
-          if (parser.index >= parser.length) return Token.Add;
+          if (parser.index >= parser.end) return Token.Add;
 
           if (parser.currentCodePoint === Chars.Plus) {
             nextCodePoint(parser);
@@ -291,7 +291,7 @@ export function scanSingleToken(parser: ParserState, context: Context): Token {
         // `-`, `--`, `-=`, `-->`
         case Token.Subtract: {
           nextCodePoint(parser);
-          if (parser.index >= parser.length) return Token.Subtract;
+          if (parser.index >= parser.end) return Token.Subtract;
           const next = parser.currentCodePoint;
 
           if (next === Chars.Hyphen) {
@@ -319,7 +319,7 @@ export function scanSingleToken(parser: ParserState, context: Context): Token {
 
         case Token.Divide: {
           nextCodePoint(parser);
-          if (parser.index < parser.length) {
+          if (parser.index < parser.end) {
             const ch = parser.currentCodePoint;
             if (ch === Chars.Slash) {
               nextCodePoint(parser);
@@ -343,7 +343,7 @@ export function scanSingleToken(parser: ParserState, context: Context): Token {
         // `<`, `<=`, `<<`, `<<=`, `</`, `<!--`
         case Token.LessThan:
           nextCodePoint(parser);
-          if (parser.index >= parser.length) return Token.LessThan;
+          if (parser.index >= parser.end) return Token.LessThan;
 
           switch (parser.currentCodePoint) {
             case Chars.LessThan:
@@ -378,7 +378,7 @@ export function scanSingleToken(parser: ParserState, context: Context): Token {
         // `=`, `==`, `===`, `=>`
         case Token.Assign: {
           nextCodePoint(parser);
-          if (parser.index >= parser.length) return Token.Assign;
+          if (parser.index >= parser.end) return Token.Assign;
           const next = parser.currentCodePoint;
 
           if (next === Chars.EqualSign) {
@@ -400,7 +400,7 @@ export function scanSingleToken(parser: ParserState, context: Context): Token {
         // `|`, `||`, `|=`
         case Token.BitwiseOr: {
           nextCodePoint(parser);
-          if (parser.index >= parser.length) return Token.BitwiseOr;
+          if (parser.index >= parser.end) return Token.BitwiseOr;
           const next = parser.currentCodePoint;
 
           if (next === Chars.VerticalBar) {
@@ -417,7 +417,7 @@ export function scanSingleToken(parser: ParserState, context: Context): Token {
         // `>`, `>=`, `>>`, `>>>`, `>>=`, `>>>=`
         case Token.GreaterThan: {
           nextCodePoint(parser);
-          if (parser.index >= parser.length) return Token.GreaterThan;
+          if (parser.index >= parser.end) return Token.GreaterThan;
           const next = parser.currentCodePoint;
 
           if (next === Chars.EqualSign) {
@@ -428,7 +428,7 @@ export function scanSingleToken(parser: ParserState, context: Context): Token {
           if (next !== Chars.GreaterThan) return Token.GreaterThan;
           nextCodePoint(parser);
 
-          if (parser.index < parser.length) {
+          if (parser.index < parser.end) {
             const next = parser.currentCodePoint;
 
             if (next === Chars.GreaterThan) {
@@ -451,7 +451,7 @@ export function scanSingleToken(parser: ParserState, context: Context): Token {
         // `&`, `&&`, `&=`
         case Token.BitwiseAnd: {
           nextCodePoint(parser);
-          if (parser.index >= parser.length) return Token.BitwiseAnd;
+          if (parser.index >= parser.end) return Token.BitwiseAnd;
           const next = parser.currentCodePoint;
 
           if (next === Chars.Ampersand) {

diff --git a/src/lexer/string.ts b/src/lexer/string.ts
@@ -46,7 +46,7 @@ export function scanString(parser: ParserState, context: Context): any {
       marker = parser.index + 1;
     }
 
-    if (parser.index >= parser.length) report(parser, Errors.UnterminatedString);
+    if (parser.index >= parser.end) report(parser, Errors.UnterminatedString);
     ch = nextCodePoint(parser);
   }
 
@@ -74,7 +74,7 @@ export function parseEscape(parser: ParserState, context: Context, first: number
     case Chars.CarriageReturn: {
       const { index } = parser;
 
-      if (index < parser.length) {
+      if (index < parser.end) {
         const ch = parser.source.charCodeAt(index);
 
         if (ch === Chars.LineFeed) {
@@ -101,7 +101,7 @@ export function parseEscape(parser: ParserState, context: Context, first: number
       let index = parser.index + 1;
       let column = parser.column + 1;
 
-      if (index < parser.length) {
+      if (index < parser.end) {
         const next = parser.source.charCodeAt(index);
 
         if ((CharTypes[next] & CharFlags.Octal) === 0) {
@@ -116,7 +116,7 @@ export function parseEscape(parser: ParserState, context: Context, first: number
           index++;
           column++;
 
-          if (index < parser.length) {
+          if (index < parser.end) {
             const next = parser.source.charCodeAt(index);
 
             if (CharTypes[next] & CharFlags.Octal) {
@@ -145,7 +145,7 @@ export function parseEscape(parser: ParserState, context: Context, first: number
       const index = parser.index + 1;
       const column = parser.column + 1;
 
-      if (index < parser.length) {
+      if (index < parser.end) {
         const next = parser.source.charCodeAt(index);
 
         if (CharTypes[next] & CharFlags.Octal) {

diff --git a/src/lexer/template.ts b/src/lexer/template.ts
@@ -41,7 +41,7 @@ export function scanTemplate(parser: ParserState, context: Context): Token {
       }
     } else {
       if (ch === Chars.CarriageReturn) {
-        if (parser.index < parser.length && parser.source.charCodeAt(parser.index) === Chars.LineFeed) {
+        if (parser.index < parser.end && parser.source.charCodeAt(parser.index) === Chars.LineFeed) {
           ret += fromCodePoint(ch);
           parser.currentCodePoint = parser.source.charCodeAt(++parser.index);
         }
@@ -53,7 +53,7 @@ export function scanTemplate(parser: ParserState, context: Context): Token {
       }
       ret += fromCodePoint(ch);
     }
-    if (parser.index >= parser.length) report(parser, Errors.UnterminatedTemplate);
+    if (parser.index >= parser.end) report(parser, Errors.UnterminatedTemplate);
     ch = nextCodePoint(parser);
   }
 
@@ -76,7 +76,7 @@ function scanBadTemplate(parser: ParserState, ch: number): number {
     switch (ch) {
       case Chars.Dollar: {
         const index = parser.index + 1;
-        if (index < parser.length && parser.source.charCodeAt(index) === Chars.LeftBrace) {
+        if (index < parser.end && parser.source.charCodeAt(index) === Chars.LeftBrace) {
           parser.index = index;
           parser.column++;
           return -ch;
@@ -93,16 +93,16 @@ function scanBadTemplate(parser: ParserState, ch: number): number {
       default:
       // do nothing
     }
-    if (parser.index >= parser.length) report(parser, Errors.UnterminatedTemplate);
+    if (parser.index >= parser.end) report(parser, Errors.UnterminatedTemplate);
     ch = nextCodePoint(parser);
   }
 
   return ch;
 }
 
-export function scanTemplateTail(state: ParserState, context: Context): Token {
-  if (state.index >= state.length) return Token.Illegal;
-  state.index--;
-  state.column--;
-  return scanTemplate(state, context);
+export function scanTemplateTail(parser: ParserState, context: Context): Token {
+  if (parser.index >= parser.end) return Token.Illegal;
+  parser.index--;
+  parser.column--;
+  return scanTemplate(parser, context);
 }