@ibyar/expressions 0.5.6 → 0.6.1

package/v8/inline.js

@@ -172,7 +172,11 @@ export class AbstractParser {
             case Token.LBRACK:
             case Token.IDENTIFIER:
             case Token.STATIC:
-            case Token.LET:
+            case Token.LET: // `let let;` is disallowed by static semantics, but the
+            // token must be first interpreted as a keyword in order
+            // for those semantics to apply. This ensures that ASI is
+            // not honored when a LineTerminator separates the
+            // tokens.
             case Token.YIELD:
             case Token.AWAIT:
             case Token.GET:
@@ -196,6 +200,7 @@ export class AbstractParser {
         return Reflect.get(expression, 'parenthesized') === true;
     }
     isAssignableIdentifier(expression) {
+        // return expression instanceof AssignmentNode;
         if (!(expression instanceof Identifier)) {
             return false;
         }
@@ -312,6 +317,24 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
         return new ExpressionStatement(list);
     }
+    /**
+     * Statement ::
+     * Block
+     * VariableStatement
+     * EmptyStatement
+     * ExpressionStatement
+     * IfStatement
+     * IterationStatement
+     * ContinueStatement
+     * BreakStatement
+     * ReturnStatement
+     * WithStatement
+     * LabelledStatement
+     * SwitchStatement
+     * ThrowStatement
+     * TryStatement
+     * DebuggerStatement
+     */
     parseStatement(allowFunction = AllowLabelledFunctionStatement.DisallowLabelledFunctionStatement) {
         switch (this.peek().token) {
             case Token.LBRACE:
@@ -362,6 +385,16 @@ export class JavaScriptInlineParser extends AbstractParser {
         return DebuggerStatement.INSTANCE;
     }
     parseTryStatement() {
+        // TryStatement ::
+        //   'try' Block Catch
+        //   'try' Block Finally
+        //   'try' Block Catch Finally
+        //
+        // Catch ::
+        //   'catch' '(' Identifier ')' Block
+        //
+        // Finally ::
+        //   'finally' Block
         this.consume(Token.TRY);
         const tryBlock = this.parseBlock();
         let peek = this.peek();
@@ -414,6 +447,24 @@ export class JavaScriptInlineParser extends AbstractParser {
         this.expect(Token.RBRACE);
         return block;
     }
+    /**
+     * ECMA 262 6th Edition
+     * 	StatementListItem[Yield, Return] :
+     * 	Statement[?Yield, ?Return]
+     * 	Declaration[?Yield]
+     * //
+     * Declaration[Yield] :
+     * 	HoistableDeclaration[?Yield]
+     * 	ClassDeclaration[?Yield]
+     * 	LexicalDeclaration[In, ?Yield]
+     * //
+     * HoistableDeclaration[Yield, Default] :
+     * 	FunctionDeclaration[?Yield, ?Default]
+     * 	GeneratorDeclaration[?Yield, ?Default]
+     * //
+     * LexicalDeclaration[In, Yield] :
+     * 	LetOrConst BindingList[?In, ?Yield] ;
+     */
     parseStatementListItem() {
         switch (this.peek().token) {
             case Token.FUNCTION:
@@ -453,6 +504,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         return this.parseFunctionLiteral(functionKind, functionSyntaxKind, name);
     }
     parseAsyncFunctionDeclaration(names, defaultExport) {
+        // AsyncFunctionDeclaration ::
+        //   async [no LineTerminator here] function BindingIdentifier[Await]
+        //       ( FormalParameters[Await] ) { AsyncFunctionBody }
         if (this.scanner.hasLineTerminatorBeforeNext()) {
             throw new SyntaxError(this.errorMessage('Line Terminator Before `function` parsing `async function`.'));
         }
@@ -481,6 +535,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
     }
     parseDoWhileStatement() {
+        // DoStatement ::
+        //   'do' Statement 'while' '(' Expression ')' ';'
         this.consume(Token.DO);
         const body = this.parseStatement();
         this.expect(Token.WHILE);
@@ -491,6 +547,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new DoWhileNode(condition, body);
     }
     parseWhileStatement() {
+        // WhileStatement ::
+        //   'while' '(' Expression ')' Statement
         this.consume(Token.WHILE);
         this.expect(Token.LPAREN);
         const condition = this.parseExpression();
@@ -499,6 +557,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new WhileNode(condition, body);
     }
     parseThrowStatement() {
+        // ThrowStatement ::
+        //   'throw' Expression ';'
         this.consume(Token.THROW);
         if (this.scanner.hasLineTerminatorBeforeNext()) {
             throw new Error(this.scanner.createError(`New line After Throw`));
@@ -508,6 +568,11 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new ThrowStatement(exception);
     }
     parseSwitchStatement() {
+        // SwitchStatement ::
+        //   'switch' '(' Expression ')' '{' CaseClause* '}'
+        // CaseClause ::
+        //   'case' Expression ':' StatementList
+        //   'default' ':' StatementList
         this.consume(Token.SWITCH);
         this.expect(Token.LPAREN);
         const tag = this.parseExpression();
@@ -547,31 +612,58 @@ export class JavaScriptInlineParser extends AbstractParser {
         return switchStatement;
     }
     parseForStatement() {
+        // Either a standard for loop
+        //   for (<init>; <cond>; <next>) { ... }
+        // or a for-each loop
+        //   for (<each> of|in <iterable>) { ... }
+        //
+        // We parse a declaration/expression after the 'for (' and then read the first
+        // expression/declaration before we know if this is a for or a for-each.
+        //   typename FunctionState::LoopScope loop_scope(function_state_);
         this.consume(Token.FOR);
         this.expect(Token.LPAREN);
         const peek = this.peek();
         const starts_with_let = peek.isType(Token.LET);
         if (peek.isType(Token.CONST) || (starts_with_let && this.isNextLetKeyword())) {
+            // The initializer contains lexical declarations,
+            // so create an in-between scope.
+            // Also record whether inner functions or evals are found inside
+            // this loop, as this information is used to simplify the desugaring
+            // if none are found.
+            // typename FunctionState::FunctionOrEvalRecordingScope recording_scope(function_state_);
             const initializer = this.parseVariableDeclarations(VariableDeclarationContext.ForStatement);
             const forMode = this.checkInOrOf();
             if (forMode) {
                 return this.parseForEachStatementWithDeclarations(initializer, forMode);
             }
             this.expect(Token.SEMICOLON);
+            // Parse the remaining code in the inner block scope since the declaration
+            // above was parsed there. We'll finalize the unnecessary outer block scope
+            // after parsing the rest of the loop.
             return this.parseStandardForLoopWithLexicalDeclarations(initializer);
         }
         let initializer;
         if (peek.isType(Token.VAR)) {
             initializer = this.parseVariableDeclarations(VariableDeclarationContext.ForStatement);
+            // ParseVariableDeclarations(kForStatement, & for_info.parsing_result,& for_info.bound_names);
+            // DCHECK_EQ(for_info.parsing_result.descriptor.mode, VariableMode:: kVar);
+            // for_info.position = scanner() -> location().beg_pos;
             const forMode = this.checkInOrOf();
             if (forMode) {
                 return this.parseForEachStatementWithDeclarations(initializer, forMode);
             }
+            // init = impl() -> BuildInitializationBlock(& for_info.parsing_result);
         }
         else if (this.peek().isNotType(Token.SEMICOLON)) {
+            // The initializer does not contain declarations.
             this.setAcceptIN(false);
             initializer = this.parseExpressionCoverGrammar();
             this.restoreAcceptIN();
+            //   ExpressionParsingScope parsing_scope(impl());
+            //   AcceptINScope scope(this, false);
+            // `for (async of` is disallowed but `for (async.x of` is allowed, so
+            // check if the token is ASYNC after parsing the expression.
+            // Initializer is reference followed by in/of.
             const expression_is_async = this.current().isType(Token.ASYNC);
             const forMode = this.checkInOrOf();
             if (forMode) {
@@ -585,9 +677,12 @@ export class JavaScriptInlineParser extends AbstractParser {
         return this.parseStandardForLoop(initializer);
     }
     parseStandardForLoopWithLexicalDeclarations(initializer) {
+        // The condition and the next statement of the for loop must be parsed
+        // in a new scope.
         return this.parseStandardForLoop(initializer);
     }
     parseForEachStatementWithDeclarations(initializer, forMode) {
+        // Just one declaration followed by in/of.
         if (initializer.getDeclarations().length != 1) {
             throw new SyntaxError(this.errorMessage('For In/Of loop Multi Bindings'));
         }
@@ -616,6 +711,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
     }
     parseStandardForLoop(initializer) {
+        // CheckStackOverflow();
+        //   ForStatementT loop = factory() -> NewForStatement(stmt_pos);
+        //   Target target(this, loop, labels, own_labels, Target:: TARGET_FOR_ANONYMOUS);
         let cond = new EmptyStatement();
         if (this.peek().isNotType(Token.SEMICOLON)) {
             cond = this.parseExpression();
@@ -630,6 +728,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new ForNode(body, initializer, cond, next);
     }
     parseForAwaitStatement() {
+        // for await '(' ForDeclaration of AssignmentExpression ')'
+        // Create an in-between scope for let-bound iteration variables.
+        //   BlockState for_state(zone(), & scope_);
         if (!this.isAwaitAllowed()) {
             throw new SyntaxError(this.errorMessage('"await" is not allowed'));
         }
@@ -637,11 +738,17 @@ export class JavaScriptInlineParser extends AbstractParser {
         this.expect(Token.AWAIT);
         this.expect(Token.LPAREN);
         let hasDeclarations = false;
+        // Scope * inner_block_scope = NewScope(BLOCK_SCOPE);
         let eachVariable;
         let peek = this.peek();
         let startsWithLet = peek.isType(Token.LET);
         if (peek.isType(Token.VAR) || peek.isType(Token.CONST)
             || (startsWithLet && this.isNextLetKeyword())) {
+            // The initializer contains declarations
+            // 'for' 'await' '(' ForDeclaration 'of' AssignmentExpression ')'
+            //     Statement
+            // 'for' 'await' '(' 'var' ForBinding 'of' AssignmentExpression ')'
+            //     Statement
             hasDeclarations = true;
             const initializer = this.parseVariableDeclarations(VariableDeclarationContext.ForStatement);
             if (initializer.getDeclarations().length != 1) {
@@ -650,6 +757,9 @@ export class JavaScriptInlineParser extends AbstractParser {
             eachVariable = initializer;
         }
         else {
+            // The initializer does not contain declarations.
+            // 'for' 'await' '(' LeftHandSideExpression 'of' AssignmentExpression ')'
+            //     Statement
             if (startsWithLet) {
                 throw new SyntaxError(this.errorMessage('The initializer does not contain declarations, For Of Let, "for-await-of"'));
             }
@@ -664,6 +774,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new ForAwaitOfNode(eachVariable, iterable, body);
     }
     parseVariableDeclarations(varContext) {
+        // VariableDeclarations ::
+        //   ('var' | 'const' | 'let') (Identifier ('=' AssignmentExpression)?)+[',']
+        // var converted into ==> 'let' by parser
         let mode;
         const token = this.peek().token;
         switch (token) {
@@ -685,11 +798,17 @@ export class JavaScriptInlineParser extends AbstractParser {
         do {
             let name;
             let value;
+            // Check for an identifier first, so that we can elide the pattern in cases
+            // where there is no initializer (and so no proxy needs to be created).
             if (Token.isAnyIdentifier(this.peek().token)) {
                 name = this.parseAndClassifyIdentifier(this.next());
                 if (isStrict(this.languageMode) && this.isEvalOrArguments(name)) {
                     throw new Error(this.errorMessage(`Strict Eval Arguments`));
                 }
+                // if (this.peekInOrOf()) {
+                // 	// // Assignments need the variable expression for the assignment LHS, and
+                // 	// // for of/in will need it later, so create the expression now.
+                // }
             }
             else {
                 name = this.parseBindingPattern(true);
@@ -700,15 +819,21 @@ export class JavaScriptInlineParser extends AbstractParser {
                 this.restoreAcceptIN();
             }
             else if (!this.peekInOrOf()) {
+                // ES6 'const' and binding patterns require initializers.
                 if (mode === 'const' && (name === undefined || value === undefined)) {
                     throw new Error(this.errorMessage(`Declaration Missing Initializer`));
                 }
+                // value = undefined;
             }
             variables.push(new VariableDeclarator(name, value));
         } while (this.check(Token.COMMA));
         return new VariableDeclarationNode(variables, mode);
     }
     parseBindingPattern(isPattern) {
+        // Pattern ::
+        //   Identifier
+        //   ArrayLiteral
+        //   ObjectLiteral
         const token = this.peek().token;
         if (Token.isAnyIdentifier(token)) {
             const name = this.parseAndClassifyIdentifier(this.next());
@@ -728,6 +853,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
     }
     parseAndClassifyIdentifier(next) {
+        // Updates made here must be reflected on ClassifyPropertyIdentifier.
         if (Token.isInRangeIdentifierAndAsync(next.token)) {
             const name = next.getValue();
             if (this.isArguments(name) && this.shouldBanArguments()) {
@@ -744,30 +870,48 @@ export class JavaScriptInlineParser extends AbstractParser {
         return next.getValue();
     }
     parseContinueStatement() {
+        // ContinueStatement ::
+        //   'continue' ';'
+        // Identifier? is not supported
         this.consume(Token.CONTINUE);
         let label;
         if (!this.scanner.hasLineTerminatorBeforeNext() &&
             !Token.isAutoSemicolon(this.peek().token)) {
+            // ECMA allows "eval" or "arguments" as labels even in strict mode.
             label = this.parseIdentifier();
         }
         this.expectSemicolon();
         return label ? new ContinueStatement(label) : ContinueStatement.CONTINUE_INSTANCE;
     }
     parseBreakStatement() {
+        // BreakStatement ::
+        //   'break' ';'
+        // Identifier? is not supported
         this.consume(Token.BREAK);
         let label;
         if (!this.scanner.hasLineTerminatorBeforeNext() &&
             !Token.isAutoSemicolon(this.peek().token)) {
+            // ECMA allows "eval" or "arguments" as labels even in strict mode.
             label = this.parseIdentifier();
         }
         this.expectSemicolon();
         return label ? new BreakStatement(label) : BreakStatement.BREAK_INSTANCE;
     }
     parseReturnStatement() {
+        // ReturnStatement ::
+        //   'return' [no line terminator] Expression? ';'
+        // Consume the return token. It is necessary to do that before
+        // reporting any errors on it, because of the way errors are
+        // reported (underlining).
         this.consume(Token.RETURN);
         const tokenExp = this.peek();
         let returnValue;
+        // ExpressionT return_value = impl() -> NullExpression();
         if (this.scanner.hasLineTerminatorBeforeNext() || Token.isAutoSemicolon(tokenExp.token)) {
+            // check if this scope is belong to 'constructor' method to return this at the end;
+            // if (this.isDerivedConstructor(this.functionKind)) {
+            // 	returnValue = ThisNode;
+            // }
         }
         else {
             returnValue = this.parseExpression();
@@ -776,6 +920,12 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new ReturnStatement(returnValue);
     }
     parseExpressionOrLabelledStatement(allowFunction) {
+        // ExpressionStatement | LabelledStatement ::
+        //   Expression ';'
+        //   Identifier ':' Statement
+        //
+        // ExpressionStatement[Yield] :
+        //   [lookahead notin {{, function, class, let [}] Expression[In, ?Yield] ;
         switch (this.peek().token) {
             case Token.FUNCTION:
             case Token.LBRACE:
@@ -784,6 +934,9 @@ export class JavaScriptInlineParser extends AbstractParser {
                 throw new Error(this.errorMessage(`Unexpected Token ${this.next().getValue().toString()}`));
             case Token.LET: {
                 const nextNext = this.peekAhead();
+                // "let" followed by either "[", "{" or an identifier means a lexical
+                // declaration, which should not appear here.
+                // However, ASI may insert a line break before an identifier or a brace.
                 if (nextNext.isNotType(Token.LBRACK) &&
                     ((nextNext.isNotType(Token.LBRACE) && nextNext.isNotType(Token.IDENTIFIER)))) {
                     break;
@@ -797,7 +950,13 @@ export class JavaScriptInlineParser extends AbstractParser {
         this.setAcceptIN(true);
         const expression = this.parseExpressionCoverGrammar();
         if (this.peek().isType(Token.COLON) && startsWithIdentifier && this.isIdentifier(expression)) {
+            // The whole expression was a single identifier, and not, e.g.,
+            // something starting with an identifier or a parenthesized identifier.
+            // Remove the "ghost" variable that turned out to be a label from the top
+            // scope. This way, we don't try to resolve it during the scope
+            // processing.
             this.consume(Token.COLON);
+            // ES#sec-labelled-function-declarations Labelled Function Declarations
             if (this.peek().isType(Token.FUNCTION)
                 && isSloppy(this.languageMode)
                 && allowFunction == AllowLabelledFunctionStatement.AllowLabelledFunctionStatement) {
@@ -810,6 +969,7 @@ export class JavaScriptInlineParser extends AbstractParser {
             return new LabeledStatement(expression, result);
         }
         this.restoreAcceptIN();
+        // Parsed expression statement, followed by semicolon.
         this.expectSemicolon();
         return expression;
     }
@@ -827,6 +987,12 @@ export class JavaScriptInlineParser extends AbstractParser {
         return this.parseHoistableDeclaration01(FunctionKind.NormalFunction, undefined, false);
     }
     parseAsyncFunctionLiteral() {
+        // AsyncFunctionLiteral ::
+        //   async [no LineTerminator here] function ( FormalParameters[Await] )
+        //       { AsyncFunctionBody }
+        //
+        //   async [no LineTerminator here] function BindingIdentifier[Await]
+        //       ( FormalParameters[Await] ) { AsyncFunctionBody }
         if (this.current().isNotType(Token.ASYNC)) {
             throw new SyntaxError(this.errorMessage('invalid token'));
         }
@@ -852,7 +1018,19 @@ export class JavaScriptInlineParser extends AbstractParser {
         return this.parseHoistableDeclaration01(flags, names, defaultExport);
     }
     parseHoistableDeclaration01(flag, names, defaultExport) {
+        // FunctionDeclaration ::
+        //   'function' Identifier '(' FormalParameters ')' '{' FunctionBody '}'
+        //   'function' '(' FormalParameters ')' '{' FunctionBody '}'
+        // GeneratorDeclaration ::
+        //   'function' '*' Identifier '(' FormalParameters ')' '{' FunctionBody '}'
+        //   'function' '*' '(' FormalParameters ')' '{' FunctionBody '}'
+        //
+        // The anonymous forms are allowed iff [default_export] is true.
+        //
+        // 'function' and '*' (if present) have been consumed by the caller.
+        // (FunctionType.ASYNC === flag || FunctionType.GENERATOR === flag);
         if ((flag & ParseFunctionFlag.IsAsync) != 0 && this.check(Token.MUL)) {
+            // Async generator
             flag |= ParseFunctionFlag.IsGenerator;
         }
         let name;
@@ -910,6 +1088,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         return current.getValue();
     }
     parseFunctionLiteral(flag, functionSyntaxKind, name) {
+        // Function ::
+        //   '(' FormalParameterList? ')' '{' FunctionBody '}'
         this.setFunctionKind(flag);
         const functionInfo = {};
         this.expect(Token.LPAREN);
@@ -927,11 +1107,17 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new FunctionExpression(formals, bodyBlock, isAsyncFunction(flag), isGeneratorFunction(flag));
     }
     parseFunctionBody(kind, bodyType, functionSyntaxKind) {
+        // Building the parameter initialization block declares the parameters.
+        // TODO(verwaest): Rely on ArrowHeadParsingScope instead.
         let innerBody;
         if (bodyType == FunctionBodyType.EXPRESSION) {
             innerBody = this.parseAssignmentExpression();
         }
         else {
+            // DCHECK(accept_IN_);
+            // DCHECK_EQ(FunctionBodyType:: kBlock, body_type);
+            // If we are parsing the source as if it is wrapped in a function, the
+            // source ends without a closing brace.
             const closing_token = functionSyntaxKind == FunctionSyntaxKind.Wrapped ? Token.EOS : Token.RBRACE;
             if (isAsyncGeneratorFunction(kind)) {
                 innerBody = this.parseAndRewriteAsyncGeneratorFunctionBody(kind);
@@ -959,6 +1145,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         return this.parseStatementList(Token.RBRACE);
     }
     parseStatementList(endToken) {
+        // StatementList ::
+        //   (StatementListItem)* <end_token>
         if (this.peek().test((token, value) => Token.STRING === token && 'use strict' === value.getValue())) {
             this.languageMode = LanguageMode.Strict;
         }
@@ -976,6 +1164,16 @@ export class JavaScriptInlineParser extends AbstractParser {
         return list;
     }
     parseFormalParameterList(functionInfo) {
+        // FormalParameters[Yield] :
+        //   [empty]
+        //   FunctionRestParameter[?Yield]
+        //   FormalParameterList[?Yield]
+        //   FormalParameterList[?Yield] ,
+        //   FormalParameterList[?Yield] , FunctionRestParameter[?Yield]
+        //
+        // FormalParameterList[Yield] :
+        //   FormalParameter[?Yield]
+        //   FormalParameterList[?Yield] , FormalParameter[?Yield]
         const parameters = [];
         if (this.peek().isNotType(Token.RPAREN)) {
             while (true) {
@@ -990,6 +1188,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                 if (!this.check(Token.COMMA))
                     break;
                 if (this.peek().isType(Token.RPAREN)) {
+                    // allow the trailing comma
                     break;
                 }
             }
@@ -997,6 +1196,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         return parameters;
     }
     parseFormalParameter(functionInfo) {
+        // FormalParameter[Yield,GeneratorParameter] :
+        //   BindingElement[?Yield, ?GeneratorParameter]
         functionInfo.rest = this.check(Token.ELLIPSIS);
         let pattern = this.parseBindingPattern(true);
         let initializer;
@@ -1015,6 +1216,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         return initializer;
     }
     parseExpressionCoverGrammar() {
+        // Expression ::
+        //   AssignmentExpression
+        //   Expression ',' AssignmentExpression
         const list = [];
         let expression;
         while (true) {
@@ -1026,6 +1230,7 @@ export class JavaScriptInlineParser extends AbstractParser {
             if (!this.check(Token.COMMA))
                 break;
             if (this.peek().isType(Token.RPAREN) && this.peekAhead().isType(Token.ARROW)) {
+                // a trailing comma is allowed at the end of an arrow parameter list
                 break;
             }
         }
@@ -1042,6 +1247,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         if (this.peek().isType(Token.COMMA)) {
             throw new Error(this.errorMessage(`Error A rest parameter or binding pattern may not have a trailing comma`));
         }
+        // 'x, y, ...z' in CoverParenthesizedExpressionAndArrowParameterList only
+        // as the formal parameters of'(x, y, ...z) => foo', and is not itself a
+        // valid expression.
         if (this.peek().isNotType(Token.RPAREN) || this.peekAhead().isNotType(Token.ARROW)) {
             throw new Error(this.errorMessage(`Error Unexpected Token At ${this.position()}`));
         }
@@ -1060,6 +1268,18 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new SequenceExpression(list);
     }
     parseMemberExpression() {
+        // MemberExpression ::
+        //   (PrimaryExpression | FunctionLiteral | ClassLiteral)
+        //     ('[' Expression ']' | '.' Identifier | Arguments | TemplateLiteral)*
+        //
+        // CallExpression ::
+        //   (SuperCall | ImportCall)
+        //     ('[' Expression ']' | '.' Identifier | Arguments | TemplateLiteral)*
+        //
+        // The '[' Expression ']' and '.' Identifier parts are parsed by
+        // ParseMemberExpressionContinuation, and everything preceeding it is merged
+        // into ParsePrimaryExpression.
+        // Parse the initial primary or function expression.
         const result = this.parsePrimaryExpression();
         return this.parseMemberExpressionContinuation(result);
     }
@@ -1073,15 +1293,31 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new Param(expression);
     }
     parsePrimaryExpression() {
+        // PrimaryExpression ::
+        //   'this'
+        //   'null'
+        //   'true'
+        //   'false'
+        //   Identifier
+        //   Number
+        //   String
+        //   ArrayLiteral
+        //   ObjectLiteral
+        //   RegExpLiteral
+        //   '(' Expression ')'
+        //   do Block
+        //   AsyncFunctionLiteral
         let token = this.peek();
         if (Token.isAnyIdentifier(token.token)) {
             this.consume(token.token);
             let kind = FunctionKind.NormalFunction;
             if (token.isType(Token.ASYNC) && !this.scanner.hasLineTerminatorBeforeNext()) {
+                // async function ...
                 if (this.peek().isType(Token.FUNCTION)) {
                     return this.parseAsyncFunctionLiteral();
                 }
                 ;
+                // async Identifier => ...
                 if (Token.isAnyIdentifier(this.peek().token) && this.peekAhead().isType(Token.ARROW)) {
                     token = this.next();
                     kind = FunctionKind.AsyncFunction;
@@ -1114,6 +1350,9 @@ export class JavaScriptInlineParser extends AbstractParser {
                 return ThisNode;
             case Token.DIV:
             case Token.DIV_ASSIGN:
+                // case Token.REGEXP_LITERAL:
+                // this.consume(Token.REGEXP_LITERAL);
+                // return token.value!;
                 return this.parseRegExpLiteral();
             case Token.FUNCTION:
                 return this.parseFunctionExpression();
@@ -1129,6 +1368,8 @@ export class JavaScriptInlineParser extends AbstractParser {
             case Token.LPAREN: {
                 this.consume(Token.LPAREN);
                 if (this.check(Token.RPAREN)) {
+                    // ()=>x.  The continuation that consumes the => is in
+                    // ParseAssignmentExpressionCoverGrammar.
                     if (!this.peek().isType(Token.ARROW)) {
                         throw new Error(this.errorMessage(`Unexpected Token: ${Token.RPAREN.getName()}`));
                     }
@@ -1136,6 +1377,8 @@ export class JavaScriptInlineParser extends AbstractParser {
                     this.markParenthesized(result);
                     return result;
                 }
+                // Heuristically try to detect immediately called functions before
+                // seeing the call parentheses.
                 this.setAcceptIN(true);
                 const expression = this.parseExpressionCoverGrammar();
                 this.markParenthesized(expression);
@@ -1155,10 +1398,23 @@ export class JavaScriptInlineParser extends AbstractParser {
         throw new Error(this.errorMessage(`Unexpected Token: ${JSON.stringify(this.next())}`));
     }
     parseTemplateLiteral(tag) {
+        // A TemplateLiteral is made up of 0 or more TEMPLATE_SPAN tokens (literal
+        // text followed by a substitution expression), finalized by a single
+        // TEMPLATE_TAIL.
+        //
+        // In terms of draft language, TEMPLATE_SPAN may be either the TemplateHead or
+        // TemplateMiddle productions, while TEMPLATE_TAIL is either TemplateTail, or
+        // NoSubstitutionTemplate.
+        //
+        // When parsing a TemplateLiteral, we must have scanned either an initial
+        // TEMPLATE_SPAN, or a TEMPLATE_TAIL.
         let next = this.peek();
         if (!Token.isTemplate(next.token)) {
             throw new SyntaxError(this.errorMessage(`Unexpected Token: ${JSON.stringify(this.next())}`));
         }
+        // If we reach a TEMPLATE_TAIL first, we are parsing a NoSubstitutionTemplate.
+        // In this case we may simply consume the token and build a template with a
+        // single TEMPLATE_SPAN and no expressions.
         if (next.isType(Token.TEMPLATE_TAIL)) {
             this.consume(Token.TEMPLATE_TAIL);
             const string = next.getValue().string;
@@ -1168,6 +1424,9 @@ export class JavaScriptInlineParser extends AbstractParser {
         const expressions = [];
         const strings = [];
         strings.push(next.getValue().string);
+        // If we open with a TEMPLATE_SPAN, we must scan the subsequent expression,
+        // and repeat if the following token is a TEMPLATE_SPAN as well (in this
+        // case, representing a TemplateMiddle).
         do {
             this.setAcceptIN(true);
             const expression = this.parseExpressionCoverGrammar();
@@ -1177,6 +1436,8 @@ export class JavaScriptInlineParser extends AbstractParser {
                 this.restoreAcceptIN();
                 throw new SyntaxError(this.errorMessage('Unterminated Template Expr'));
             }
+            // If we didn't die parsing that expression, our next token should be a
+            // TEMPLATE_SPAN or TEMPLATE_TAIL.
             next = this.scanner.scanTemplateContinuation();
             strings.push(next.getValue().string);
             this.restoreAcceptIN();
@@ -1184,6 +1445,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         if (next.isNotType(Token.TEMPLATE_TAIL)) {
             throw new SyntaxError(this.errorMessage(`Unexpected Token: ${JSON.stringify(next)}`));
         }
+        // Once we've reached a TEMPLATE_TAIL, we can close the TemplateLiteral.
         return this.createTemplateLiteralExpressionNode(strings, expressions, tag);
     }
     createTemplateLiteralExpressionNode(strings, expressions, tag) {
@@ -1195,8 +1457,27 @@ export class JavaScriptInlineParser extends AbstractParser {
         }
     }
     parseMemberWithPresentNewPrefixesExpression() {
+        // NewExpression ::
+        //   ('new')+ MemberExpression
+        //
+        // NewTarget ::
+        //   'new' '.' 'target'
+        // The grammar for new expressions is pretty warped. We can have several 'new'
+        // keywords following each other, and then a MemberExpression. When we see '('
+        // after the MemberExpression, it's associated with the rightmost unassociated
+        // 'new' to create a NewExpression with arguments. However, a NewExpression
+        // can also occur without arguments.
+        // Examples of new expression:
+        // new foo.bar().baz means (new (foo.bar)()).baz
+        // new foo()() means (new foo())()
+        // new new foo()() means (new (new foo())())
+        // new new foo means new (new foo)
+        // new new foo() means new (new foo())
+        // new new foo().bar().baz means (new (new foo()).bar()).baz
+        // new super.x means new (super.x)
         this.consume(Token.NEW);
         let result;
+        // CheckStackOverflow();
         if (this.peek().isType(Token.IMPORT) && this.peekAhead().isType(Token.LPAREN)) {
             throw new SyntaxError(this.errorMessage(`Import Call Not New Expression`));
         }
@@ -1207,12 +1488,15 @@ export class JavaScriptInlineParser extends AbstractParser {
         else {
             result = this.parseMemberExpression();
             if (result === SuperIdentifier) {
+                // new super() is never allowed
                 throw new SyntaxError(this.errorMessage(`Unexpected Super, new super() is never allowed`));
             }
         }
         if (this.peek().isType(Token.LPAREN)) {
+            // NewExpression with arguments.
             const args = this.parseArguments();
             result = new NewExpression(result, args);
+            // The expression can still continue with . or [ after the arguments.
             return this.parseMemberExpressionContinuation(result);
         }
         if (this.peek().isType(Token.QUESTION_PERIOD)) {
@@ -1221,6 +1505,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new NewExpression(result);
     }
     parseArguments(maybeArrow) {
+        // Arguments ::
+        //   '(' (AssignmentExpression)*[','] ')'
         this.consume(Token.LPAREN);
         const args = [];
         while (this.peek().isNotType(Token.RPAREN)) {
@@ -1253,6 +1539,11 @@ export class JavaScriptInlineParser extends AbstractParser {
         return args;
     }
     parseAssignmentExpressionCoverGrammar() {
+        // AssignmentExpression ::
+        //   ConditionalExpression
+        //   ArrowFunction
+        //   YieldExpression
+        //   LeftHandSideExpression AssignmentOperator AssignmentExpression
         if (this.peek().isType(Token.YIELD) && isGeneratorFunction(this.functionKind)) {
             return this.parseYieldExpression();
         }
@@ -1263,6 +1554,7 @@ export class JavaScriptInlineParser extends AbstractParser {
             return expression;
         }
         ;
+        // Arrow functions.
         if (op === Token.ARROW) {
             if (!this.isIdentifier(expression) && !this.isParenthesized(expression)) {
                 throw new Error(this.errorMessage(`Malformed Arrow Fun Param List`));
@@ -1301,9 +1593,11 @@ export class JavaScriptInlineParser extends AbstractParser {
         else if (this.isProperty(expression)) {
         }
         else if (this.isPattern(expression) && Token.isAssignment(op)) {
+            // Destructuring assignment.
             expression = expression instanceof ObjectExpression
                 ? new ObjectPattern(expression.getProperties())
                 : new ArrayPattern(expression.getElements());
+            // expression_scope() -> ValidateAsPattern(expression, lhs_beg_pos, end_position());
         }
         else {
             if (!this.isValidReferenceExpression(expression)) {
@@ -1314,7 +1608,9 @@ export class JavaScriptInlineParser extends AbstractParser {
             }
         }
         this.consume(op);
+        // const opPosition = this.position();
         const right = this.parseAssignmentExpression();
+        // Anonymous function name inference applies to =, ||=, &&=, and ??=.
         if (!Token.isAssignment(op)) {
             throw new Error(this.errorMessage(`Invalid Destructuring Target`));
         }
@@ -1352,6 +1648,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         return this.scanner.currentToken().getValue();
     }
     parseArrayLiteral(isPattern) {
+        // ArrayLiteral ::
+        //   '[' Expression? (',' Expression?)* ']'
         this.consume(Token.LBRACK);
         let first_spread_index = -1;
         const values = [];
@@ -1391,6 +1689,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         return this.parseAssignmentExpressionCoverGrammar();
     }
     parseObjectLiteral(isPattern) {
+        // ObjectLiteral ::
+        // '{' (PropertyDefinition (',' PropertyDefinition)* ','? )? '}'
         this.consume(Token.LBRACE);
         const properties = [];
         while (!this.check(Token.RBRACE)) {
@@ -1425,6 +1725,12 @@ export class JavaScriptInlineParser extends AbstractParser {
             case PropertyKind.Assign:
             case PropertyKind.ShorthandOrClassField:
             case PropertyKind.Shorthand: {
+                // PropertyDefinition
+                //    IdentifierReference
+                //    CoverInitializedName
+                //
+                // CoverInitializedName
+                //    IdentifierReference Initializer?
                 const lhs = new Identifier(propInfo.name);
                 if (!this.isAssignableIdentifier(lhs)) {
                     throw new Error(this.errorMessage('Strict Eval Arguments'));
@@ -1443,6 +1749,9 @@ export class JavaScriptInlineParser extends AbstractParser {
                 return new Property(nameExpression, value, 'init', false, propInfo.kind !== PropertyKind.Assign, propInfo.isComputedName);
             }
             case PropertyKind.Method: {
+                // MethodDefinition
+                //    PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
+                //    '*' PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
                 const kind = this.methodKindFor(propInfo.isStatic, propInfo.funcFlag);
                 const value = this.parseFunctionLiteral(kind, FunctionSyntaxKind.AccessorOrMethod, propInfo.name ? new Identifier(propInfo.name) : undefined);
                 return new Property(nameExpression, value, 'init', true, false, propInfo.isComputedName);
@@ -1462,6 +1771,7 @@ export class JavaScriptInlineParser extends AbstractParser {
     parseProperty(propInfo) {
         let nextToken = this.peek();
         if (this.check(Token.ASYNC)) {
+            // async
             nextToken = this.peek();
             if (nextToken.isNotType(Token.MUL)
                 && propInfo.parsePropertyKindFromToken(nextToken.token)
@@ -1472,6 +1782,7 @@ export class JavaScriptInlineParser extends AbstractParser {
             propInfo.funcFlag = ParseFunctionFlag.IsAsync;
         }
         if (this.check(Token.MUL)) {
+            // async*
             propInfo.kind = PropertyKind.Method;
             propInfo.funcFlag = ParseFunctionFlag.IsGenerator;
         }
@@ -1506,11 +1817,15 @@ export class JavaScriptInlineParser extends AbstractParser {
             case Token.STRING:
             case Token.NUMBER:
             case Token.BIGINT:
+                //   "12" -> 12
+                //   12.3 -> "12.3"
+                //   12.30 -> "12.3"
                 this.consume(nextToken.token);
                 propertyName = nextToken.getValue();
                 propInfo.name = propertyName.getValue();
                 break;
             case Token.LBRACK:
+                // [Symbol.iterator]
                 this.consume(Token.LBRACK);
                 this.setAcceptIN(true);
                 propertyName = this.parseAssignmentExpression();
@@ -1556,6 +1871,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         if (!Token.isMember(this.peek().token)) {
             throw new Error(this.errorMessage(`Parsing member expression`));
         }
+        // Parses this part of MemberExpression:
+        // ('[' Expression ']' | '.' Identifier | TemplateLiteral)*
         do {
             switch (this.peek().token) {
                 case Token.LBRACK: {
@@ -1589,12 +1906,23 @@ export class JavaScriptInlineParser extends AbstractParser {
         if (next.isType(Token.IDENTIFIER) || next.isType(Token.PRIVATE_NAME)) {
             return next.getValue();
         }
+        // check keyword as identifier
         if (Token.isPropertyName(next.token) && next.isNotType(Token.EOS)) {
             return new Identifier(next.token.getName());
         }
         throw new SyntaxError(this.errorMessage(`Parsing property expression: Unexpected Token`));
     }
     parsePipelineExpression(expression) {
+        // ConditionalExpression ::
+        //   LogicalExpression
+        //   expression '|>' function [':' expression [':'? expression] ] *
+        //   expression '|>' function '('[expression ','?]* ')'
+        //
+        //   expression '|>' function ':' expression [':' expression | '?']*]
+        //   expression '|>' function '(' expression [',' expression | '?']* ')'
+        //
+        // [~Await]PipelineExpression[?In, ?Yield, ?Await] |> LogicalORExpression[?In, ?Yield, ?Await]
+        // [+Await]PipelineExpression[? In, ? Yield, ? Await] |> [lookahead ∉ { await }]LogicalORExpression[? In, ? Yield, ? Await]
         let token;
         while (Token.isPipelineOperator(token = this.peek().token)) {
             this.consume(token);
@@ -1605,13 +1933,16 @@ export class JavaScriptInlineParser extends AbstractParser {
     parsePipelineBody(lhs) {
         let body;
         let token = this.peek();
+        // parse function
         switch (token.token) {
             case Token.FUNCTION:
                 body = this.parseFunctionExpression();
                 break;
             case Token.ASYNC:
-                this.consume(Token.ASYNC);
-                body = this.parseAsyncFunctionLiteral();
+                if (this.peekAhead().isType(Token.FUNCTION) && !this.scanner.hasLineTerminatorAfterNext()) {
+                    this.consume(Token.ASYNC);
+                    body = this.parseAsyncFunctionLiteral();
+                }
                 break;
             default:
                 break;
@@ -1620,13 +1951,17 @@ export class JavaScriptInlineParser extends AbstractParser {
             return new PipelineExpression(lhs, body);
         }
         if (token.isType(Token.LPAREN)) {
+            // parse arrow function
+            // x |> ( y => y+1 )
             body = this.parsePrimaryExpression();
             return new PipelineExpression(lhs, body);
         }
-        const func = this.parseMemberExpression();
+        // parse angular-like and f# and partial operator syntax
+        const func = this.parseMemberExpression(); //this.parseLogicalExpression();
         let args = [];
         switch (this.peek().token) {
             case Token.COLON:
+                // support angular pipeline syntax
                 do {
                     this.consume(Token.COLON);
                     const isSpread = this.check(Token.ELLIPSIS);
@@ -1651,6 +1986,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                 } while (this.peek().isType(Token.COLON));
                 break;
             case Token.LPAREN:
+                // es2022 syntax, F# & partial operator
                 this.consume(Token.LPAREN);
                 let indexed = false;
                 while (this.peek().isNotType(Token.RPAREN)) {
@@ -1677,7 +2013,9 @@ export class JavaScriptInlineParser extends AbstractParser {
                     this.check(Token.COMMA);
                 }
                 this.expect(Token.RPAREN);
+                // should be indexed, has partial operator
                 if (!indexed) {
+                    // z |> method(x, y) === method(x, y)(z)
                     body = new CallExpression(func, args);
                     return new PipelineExpression(lhs, body);
                 }
@@ -1688,14 +2026,24 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new PipelineExpression(lhs, func, args);
     }
     parseConditionalExpression() {
+        // ConditionalExpression ::
+        //   LogicalExpression
+        //   LogicalExpression '?' AssignmentExpression ':' AssignmentExpression
+        //
         let expression = this.parseLogicalExpression();
         expression = this.parsePipelineExpression(expression);
         return this.peek().isType(Token.CONDITIONAL) ? this.parseConditionalContinuation(expression) : expression;
     }
     parseLogicalExpression() {
+        // LogicalExpression ::
+        //   LogicalORExpression
+        //   CoalesceExpression
+        // Both LogicalORExpression and CoalesceExpression start with BitwiseOR.
+        // Parse for binary expressions >= 6 (BitwiseOR);
         let expression = this.parseBinaryExpression(6);
         const peek = this.peek();
         if (peek.isType(Token.AND) || peek.isType(Token.OR)) {
+            // LogicalORExpression, pickup parsing where we left off.
             const precedence = Token.precedence(peek.token, this.acceptIN);
             expression = this.parseBinaryContinuation(expression, 4, precedence);
         }
@@ -1706,13 +2054,18 @@ export class JavaScriptInlineParser extends AbstractParser {
     }
     parseBinaryContinuation(x, prec, prec1) {
         do {
+            // prec1 >= 4
             while (Token.precedence(this.peek().token, this.acceptIN) === prec1) {
                 let y;
                 let op = this.next();
                 const is_right_associative = op.isType(Token.EXP);
                 const next_prec = is_right_associative ? prec1 : prec1 + 1;
                 y = this.parseBinaryExpression(next_prec);
+                // For now we distinguish between comparisons and other binary
+                // operations.  (We could combine the two and get rid of this
+                // code and AST node eventually.)
                 if (Token.isCompare(op.token)) {
+                    // We have a comparison.
                     let cmp = op.token;
                     switch (op.token) {
                         case Token.NE:
@@ -1725,6 +2078,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     }
                     x = shortcutNumericLiteralBinaryExpression(x, y, cmp);
                     if (op.isNotType(cmp)) {
+                        // The comparison was negated - add a NOT.
                         x = buildUnaryExpression(x, Token.NOT);
                     }
                 }
@@ -1736,7 +2090,10 @@ export class JavaScriptInlineParser extends AbstractParser {
         } while (prec1 >= prec);
         return x;
     }
+    // Precedence >= 4
     parseBinaryExpression(precedence) {
+        // "#foo in ShiftExpression" needs to be parsed separately, since private
+        // identifiers are not valid PrimaryExpressions.
         if (this.peek().isType(Token.PRIVATE_NAME)) {
             const x = this.parsePropertyOrPrivatePropertyName();
             const precedence1 = Token.precedence(this.peek().token, this.acceptIN);
@@ -1753,6 +2110,18 @@ export class JavaScriptInlineParser extends AbstractParser {
         return x;
     }
     parseUnaryExpression() {
+        // UnaryExpression ::
+        //   PostfixExpression
+        //   'delete' UnaryExpression
+        //   'void' UnaryExpression
+        //   'typeof' UnaryExpression
+        //   '++' UnaryExpression
+        //   '--' UnaryExpression
+        //   '+' UnaryExpression
+        //   '-' UnaryExpression
+        //   '~' UnaryExpression
+        //   '!' UnaryExpression
+        //   [+Await] AwaitExpression[?Yield]
         const op = this.peek();
         if (Token.isUnaryOrCount(op.token)) {
             return this.parseUnaryOrPrefixExpression();
@@ -1768,6 +2137,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         if (Token.isUnary(op.token)) {
             if (op.isType(Token.DELETE)) {
                 if (this.isIdentifier(expression) && isStrict(this.languageMode)) {
+                    // "delete identifier" is a syntax error in strict mode.
                     throw new Error(this.errorMessage(`"delete identifier" is a syntax error in strict mode`));
                 }
                 if (expression instanceof MemberExpression && expression.getProperty().toString().startsWith('#')) {
@@ -1779,11 +2149,14 @@ export class JavaScriptInlineParser extends AbstractParser {
             }
         }
         if (Token.isCount(op.token) || Token.isUnary(op.token)) {
+            // Allow the parser to rewrite the expression.
             return buildUnaryExpression(expression, op.token);
         }
         throw new Error(this.errorMessage(`while rewrite unary operation`));
     }
     parsePostfixExpression() {
+        // PostfixExpression ::
+        //   LeftHandSideExpression ('++' | '--')?
         const expression = this.parseLeftHandSideExpression();
         if (!Token.isCount(this.peek().token) || this.scanner.hasLineTerminatorBeforeNext()) {
             return expression;
@@ -1798,6 +2171,8 @@ export class JavaScriptInlineParser extends AbstractParser {
         return buildPostfixExpression(expression, op.token);
     }
     parseLeftHandSideExpression() {
+        // LeftHandSideExpression ::
+        //   (NewExpression | MemberExpression) ...
         const result = this.parseMemberExpression();
         if (!Token.isPropertyOrCall(this.peek().token))
             return result;
@@ -1810,8 +2185,10 @@ export class JavaScriptInlineParser extends AbstractParser {
             && !this.scanner.hasLineTerminatorBeforeNext()) {
             const args = this.parseArguments(ParsingArrowHeadFlag.AsyncArrowFunction);
             if (this.peek().isType(Token.ARROW)) {
+                // async () => ...
                 if (!args.length)
                     return new EmptyStatement;
+                // async ( Arguments ) => ...
                 return this.expressionListToExpression(args);
             }
             result = new CallExpression(result, args);
@@ -1822,6 +2199,7 @@ export class JavaScriptInlineParser extends AbstractParser {
         let isOptional = false;
         do {
             switch (this.peek().token) {
+                // chain
                 case Token.QUESTION_PERIOD: {
                     if (isOptional) {
                         throw new Error(this.errorMessage(`Failure Expression`));
@@ -1835,6 +2213,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     result = new MemberExpression(result, key, false, isOptional);
                     break;
                 }
+                /* Property */
                 case Token.LBRACK: {
                     this.consume(Token.LBRACK);
                     this.setAcceptIN(true);
@@ -1844,6 +2223,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     this.expect(Token.RBRACK);
                     break;
                 }
+                /* Property */
                 case Token.PERIOD: {
                     if (isOptional) {
                         throw new Error(this.errorMessage(`Unexpected Token:${this.position()}`));
@@ -1853,11 +2233,13 @@ export class JavaScriptInlineParser extends AbstractParser {
                     result = new MemberExpression(result, key, false, isOptional);
                     break;
                 }
+                /* Call */
                 case Token.LPAREN: {
                     const args = this.parseArguments();
                     result = new CallExpression(result, args, isOptional);
                     break;
                 }
+                /* bind call */
                 case Token.BIND: {
                     if (isOptional) {
                         throw new Error(this.errorMessage(`Unexpected Token:${this.position()}`));
@@ -1867,6 +2249,7 @@ export class JavaScriptInlineParser extends AbstractParser {
                     result = new BindExpression(result, key, false, isOptional);
                     break;
                 }
+                /* chain bind call */
                 case Token.QUESTION_BIND: {
                     if (isOptional) {
                         throw new Error(this.errorMessage(`Failure Expression`));
@@ -1879,9 +2262,11 @@ export class JavaScriptInlineParser extends AbstractParser {
                     break;
                 }
                 default:
+                    // Template literals in/after an Optional Chain not supported:
                     if (optionalChaining) {
                         throw new Error(this.errorMessage(`Optional Chaining No Template support`));
                     }
+                    /* Tagged Template */
                     result = this.parseTemplateLiteral(result);
                     break;
             }
@@ -1903,10 +2288,19 @@ export class JavaScriptInlineParser extends AbstractParser {
         return buildUnaryExpression(value, Token.AWAIT);
     }
     parseNullishExpression(expression) {
+        // CoalesceExpression ::
+        //   CoalesceExpressionHead ?? BitwiseORExpression
+        //
+        //   CoalesceExpressionHead ::
+        //     CoalesceExpression
+        //     BitwiseORExpression
+        // We create a binary operation for the first nullish, otherwise collapse
+        // into an nary expression.
         const list = [];
         list.push(expression);
         while (this.peek().isType(Token.NULLISH)) {
             this.consume(Token.NULLISH);
+            // Parse BitwiseOR or higher.
             expression = this.parseBinaryExpression(6);
             list.push(expression);
         }
@@ -1925,8 +2319,10 @@ export class JavaScriptInlineParser extends AbstractParser {
         return new ConditionalExpression(expression, left, right);
     }
     parseYieldExpression() {
+        // YieldExpression ::
+        //   'yield' ([no line terminator] '*'? AssignmentExpression)?
         this.consume(Token.YIELD);
-        let delegating = false;
+        let delegating = false; // yield*
         let expression;
         if (!this.scanner.hasLineTerminatorBeforeNext()) {
             if (this.check(Token.MUL)) {
@@ -1941,8 +2337,14 @@ export class JavaScriptInlineParser extends AbstractParser {
                 case Token.COLON:
                 case Token.COMMA:
                 case Token.IN:
+                    // The above set of tokens is the complete set of tokens that can appear
+                    // after an AssignmentExpression, and none of them can start an
+                    // AssignmentExpression.  This allows us to avoid looking for an RHS for
+                    // a regular yield, given only one look-ahead token.
                     if (!delegating)
                         break;
+                    // Delegating yields require an RHS; fall through.
+                    // V8_FALLTHROUGH;
                     throw new Error(this.errorMessage(`Delegating yields require an RHS`));
                 default:
                     expression = this.parseAssignmentExpressionCoverGrammar();