less 3.10.1 → 3.11.1

package/packages/less/node_modules/chevrotain/lib_esm/src/parse/parser/traits/recoverable.js

@@ -0,0 +1,305 @@
+import { createTokenInstance, EOF } from "../../../scan/tokens_public";
+import { cloneArr, contains, dropRight, find, flatten, has, isEmpty, map } from "../../../utils/utils";
+import { MismatchedTokenException } from "../../exceptions_public";
+import { IN } from "../../constants";
+import { DEFAULT_PARSER_CONFIG } from "../parser";
+export var EOF_FOLLOW_KEY = {};
+export var IN_RULE_RECOVERY_EXCEPTION = "InRuleRecoveryException";
+export function InRuleRecoveryException(message) {
+    this.name = IN_RULE_RECOVERY_EXCEPTION;
+    this.message = message;
+}
+InRuleRecoveryException.prototype = Error.prototype;
+/**
+ * This trait is responsible for the error recovery and fault tolerant logic
+ */
+var Recoverable = /** @class */ (function () {
+    function Recoverable() {
+    }
+    Recoverable.prototype.initRecoverable = function (config) {
+        this.firstAfterRepMap = {};
+        this.resyncFollows = {};
+        this.recoveryEnabled = has(config, "recoveryEnabled")
+            ? config.recoveryEnabled
+            : DEFAULT_PARSER_CONFIG.recoveryEnabled;
+        // performance optimization, NOOP will be inlined which
+        // effectively means that this optional feature does not exist
+        // when not used.
+        if (this.recoveryEnabled) {
+            this.attemptInRepetitionRecovery = attemptInRepetitionRecovery;
+        }
+    };
+    Recoverable.prototype.getTokenToInsert = function (tokType) {
+        var tokToInsert = createTokenInstance(tokType, "", NaN, NaN, NaN, NaN, NaN, NaN);
+        tokToInsert.isInsertedInRecovery = true;
+        return tokToInsert;
+    };
+    Recoverable.prototype.canTokenTypeBeInsertedInRecovery = function (tokType) {
+        return true;
+    };
+    Recoverable.prototype.tryInRepetitionRecovery = function (grammarRule, grammarRuleArgs, lookAheadFunc, expectedTokType) {
+        var _this = this;
+        // TODO: can the resyncTokenType be cached?
+        var reSyncTokType = this.findReSyncTokenType();
+        var savedLexerState = this.exportLexerState();
+        var resyncedTokens = [];
+        var passedResyncPoint = false;
+        var nextTokenWithoutResync = this.LA(1);
+        var currToken = this.LA(1);
+        var generateErrorMessage = function () {
+            var previousToken = _this.LA(0);
+            // we are preemptively re-syncing before an error has been detected, therefor we must reproduce
+            // the error that would have been thrown
+            var msg = _this.errorMessageProvider.buildMismatchTokenMessage({
+                expected: expectedTokType,
+                actual: nextTokenWithoutResync,
+                previous: previousToken,
+                ruleName: _this.getCurrRuleFullName()
+            });
+            var error = new MismatchedTokenException(msg, nextTokenWithoutResync, _this.LA(0));
+            // the first token here will be the original cause of the error, this is not part of the resyncedTokens property.
+            error.resyncedTokens = dropRight(resyncedTokens);
+            _this.SAVE_ERROR(error);
+        };
+        while (!passedResyncPoint) {
+            // re-synced to a point where we can safely exit the repetition/
+            if (this.tokenMatcher(currToken, expectedTokType)) {
+                generateErrorMessage();
+                return; // must return here to avoid reverting the inputIdx
+            }
+            else if (lookAheadFunc.call(this)) {
+                // we skipped enough tokens so we can resync right back into another iteration of the repetition grammar rule
+                generateErrorMessage();
+                // recursive invocation in other to support multiple re-syncs in the same top level repetition grammar rule
+                grammarRule.apply(this, grammarRuleArgs);
+                return; // must return here to avoid reverting the inputIdx
+            }
+            else if (this.tokenMatcher(currToken, reSyncTokType)) {
+                passedResyncPoint = true;
+            }
+            else {
+                currToken = this.SKIP_TOKEN();
+                this.addToResyncTokens(currToken, resyncedTokens);
+            }
+        }
+        // we were unable to find a CLOSER point to resync inside the Repetition, reset the state.
+        // The parsing exception we were trying to prevent will happen in the NEXT parsing step. it may be handled by
+        // "between rules" resync recovery later in the flow.
+        this.importLexerState(savedLexerState);
+    };
+    Recoverable.prototype.shouldInRepetitionRecoveryBeTried = function (expectTokAfterLastMatch, nextTokIdx, notStuck) {
+        // Edge case of arriving from a MANY repetition which is stuck
+        // Attempting recovery in this case could cause an infinite loop
+        if (notStuck === false) {
+            return false;
+        }
+        // arguments to try and perform resync into the next iteration of the many are missing
+        if (expectTokAfterLastMatch === undefined || nextTokIdx === undefined) {
+            return false;
+        }
+        // no need to recover, next token is what we expect...
+        if (this.tokenMatcher(this.LA(1), expectTokAfterLastMatch)) {
+            return false;
+        }
+        // error recovery is disabled during backtracking as it can make the parser ignore a valid grammar path
+        // and prefer some backtracking path that includes recovered errors.
+        if (this.isBackTracking()) {
+            return false;
+        }
+        // if we can perform inRule recovery (single token insertion or deletion) we always prefer that recovery algorithm
+        // because if it works, it makes the least amount of changes to the input stream (greedy algorithm)
+        //noinspection RedundantIfStatementJS
+        if (this.canPerformInRuleRecovery(expectTokAfterLastMatch, this.getFollowsForInRuleRecovery(expectTokAfterLastMatch, nextTokIdx))) {
+            return false;
+        }
+        return true;
+    };
+    // Error Recovery functionality
+    Recoverable.prototype.getFollowsForInRuleRecovery = function (tokType, tokIdxInRule) {
+        var grammarPath = this.getCurrentGrammarPath(tokType, tokIdxInRule);
+        var follows = this.getNextPossibleTokenTypes(grammarPath);
+        return follows;
+    };
+    Recoverable.prototype.tryInRuleRecovery = function (expectedTokType, follows) {
+        if (this.canRecoverWithSingleTokenInsertion(expectedTokType, follows)) {
+            var tokToInsert = this.getTokenToInsert(expectedTokType);
+            return tokToInsert;
+        }
+        if (this.canRecoverWithSingleTokenDeletion(expectedTokType)) {
+            var nextTok = this.SKIP_TOKEN();
+            this.consumeToken();
+            return nextTok;
+        }
+        throw new InRuleRecoveryException("sad sad panda");
+    };
+    Recoverable.prototype.canPerformInRuleRecovery = function (expectedToken, follows) {
+        return (this.canRecoverWithSingleTokenInsertion(expectedToken, follows) ||
+            this.canRecoverWithSingleTokenDeletion(expectedToken));
+    };
+    Recoverable.prototype.canRecoverWithSingleTokenInsertion = function (expectedTokType, follows) {
+        var _this = this;
+        if (!this.canTokenTypeBeInsertedInRecovery(expectedTokType)) {
+            return false;
+        }
+        // must know the possible following tokens to perform single token insertion
+        if (isEmpty(follows)) {
+            return false;
+        }
+        var mismatchedTok = this.LA(1);
+        var isMisMatchedTokInFollows = find(follows, function (possibleFollowsTokType) {
+            return _this.tokenMatcher(mismatchedTok, possibleFollowsTokType);
+        }) !== undefined;
+        return isMisMatchedTokInFollows;
+    };
+    Recoverable.prototype.canRecoverWithSingleTokenDeletion = function (expectedTokType) {
+        var isNextTokenWhatIsExpected = this.tokenMatcher(this.LA(2), expectedTokType);
+        return isNextTokenWhatIsExpected;
+    };
+    Recoverable.prototype.isInCurrentRuleReSyncSet = function (tokenTypeIdx) {
+        var followKey = this.getCurrFollowKey();
+        var currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey);
+        return contains(currentRuleReSyncSet, tokenTypeIdx);
+    };
+    Recoverable.prototype.findReSyncTokenType = function () {
+        var allPossibleReSyncTokTypes = this.flattenFollowSet();
+        // this loop will always terminate as EOF is always in the follow stack and also always (virtually) in the input
+        var nextToken = this.LA(1);
+        var k = 2;
+        while (true) {
+            var nextTokenType = nextToken.tokenType;
+            if (contains(allPossibleReSyncTokTypes, nextTokenType)) {
+                return nextTokenType;
+            }
+            nextToken = this.LA(k);
+            k++;
+        }
+    };
+    Recoverable.prototype.getCurrFollowKey = function () {
+        // the length is at least one as we always add the ruleName to the stack before invoking the rule.
+        if (this.RULE_STACK.length === 1) {
+            return EOF_FOLLOW_KEY;
+        }
+        var currRuleShortName = this.getLastExplicitRuleShortName();
+        var currRuleIdx = this.getLastExplicitRuleOccurrenceIndex();
+        var prevRuleShortName = this.getPreviousExplicitRuleShortName();
+        return {
+            ruleName: this.shortRuleNameToFullName(currRuleShortName),
+            idxInCallingRule: currRuleIdx,
+            inRule: this.shortRuleNameToFullName(prevRuleShortName)
+        };
+    };
+    Recoverable.prototype.buildFullFollowKeyStack = function () {
+        var _this = this;
+        var explicitRuleStack = this.RULE_STACK;
+        var explicitOccurrenceStack = this.RULE_OCCURRENCE_STACK;
+        if (!isEmpty(this.LAST_EXPLICIT_RULE_STACK)) {
+            explicitRuleStack = map(this.LAST_EXPLICIT_RULE_STACK, function (idx) { return _this.RULE_STACK[idx]; });
+            explicitOccurrenceStack = map(this.LAST_EXPLICIT_RULE_STACK, function (idx) { return _this.RULE_OCCURRENCE_STACK[idx]; });
+        }
+        // TODO: only iterate over explicit rules here
+        return map(explicitRuleStack, function (ruleName, idx) {
+            if (idx === 0) {
+                return EOF_FOLLOW_KEY;
+            }
+            return {
+                ruleName: _this.shortRuleNameToFullName(ruleName),
+                idxInCallingRule: explicitOccurrenceStack[idx],
+                inRule: _this.shortRuleNameToFullName(explicitRuleStack[idx - 1])
+            };
+        });
+    };
+    Recoverable.prototype.flattenFollowSet = function () {
+        var _this = this;
+        var followStack = map(this.buildFullFollowKeyStack(), function (currKey) {
+            return _this.getFollowSetFromFollowKey(currKey);
+        });
+        return flatten(followStack);
+    };
+    Recoverable.prototype.getFollowSetFromFollowKey = function (followKey) {
+        if (followKey === EOF_FOLLOW_KEY) {
+            return [EOF];
+        }
+        var followName = followKey.ruleName +
+            followKey.idxInCallingRule +
+            IN +
+            followKey.inRule;
+        return this.resyncFollows[followName];
+    };
+    // It does not make any sense to include a virtual EOF token in the list of resynced tokens
+    // as EOF does not really exist and thus does not contain any useful information (line/column numbers)
+    Recoverable.prototype.addToResyncTokens = function (token, resyncTokens) {
+        if (!this.tokenMatcher(token, EOF)) {
+            resyncTokens.push(token);
+        }
+        return resyncTokens;
+    };
+    Recoverable.prototype.reSyncTo = function (tokType) {
+        var resyncedTokens = [];
+        var nextTok = this.LA(1);
+        while (this.tokenMatcher(nextTok, tokType) === false) {
+            nextTok = this.SKIP_TOKEN();
+            this.addToResyncTokens(nextTok, resyncedTokens);
+        }
+        // the last token is not part of the error.
+        return dropRight(resyncedTokens);
+    };
+    Recoverable.prototype.attemptInRepetitionRecovery = function (prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {
+        // by default this is a NO-OP
+        // The actual implementation is with the function(not method) below
+    };
+    Recoverable.prototype.getCurrentGrammarPath = function (tokType, tokIdxInRule) {
+        var pathRuleStack = this.getHumanReadableRuleStack();
+        var pathOccurrenceStack = cloneArr(this.RULE_OCCURRENCE_STACK);
+        var grammarPath = {
+            ruleStack: pathRuleStack,
+            occurrenceStack: pathOccurrenceStack,
+            lastTok: tokType,
+            lastTokOccurrence: tokIdxInRule
+        };
+        return grammarPath;
+    };
+    Recoverable.prototype.getHumanReadableRuleStack = function () {
+        var _this = this;
+        if (!isEmpty(this.LAST_EXPLICIT_RULE_STACK)) {
+            return map(this.LAST_EXPLICIT_RULE_STACK, function (currIdx) {
+                return _this.shortRuleNameToFullName(_this.RULE_STACK[currIdx]);
+            });
+        }
+        else {
+            return map(this.RULE_STACK, function (currShortName) {
+                return _this.shortRuleNameToFullName(currShortName);
+            });
+        }
+    };
+    return Recoverable;
+}());
+export { Recoverable };
+export function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {
+    var key = this.getKeyForAutomaticLookahead(dslMethodIdx, prodOccurrence);
+    var firstAfterRepInfo = this.firstAfterRepMap[key];
+    if (firstAfterRepInfo === undefined) {
+        var currRuleName = this.getCurrRuleFullName();
+        var ruleGrammar = this.getGAstProductions()[currRuleName];
+        var walker = new nextToksWalker(ruleGrammar, prodOccurrence);
+        firstAfterRepInfo = walker.startWalking();
+        this.firstAfterRepMap[key] = firstAfterRepInfo;
+    }
+    var expectTokAfterLastMatch = firstAfterRepInfo.token;
+    var nextTokIdx = firstAfterRepInfo.occurrence;
+    var isEndOfRule = firstAfterRepInfo.isEndOfRule;
+    // special edge case of a TOP most repetition after which the input should END.
+    // this will force an attempt for inRule recovery in that scenario.
+    if (this.RULE_STACK.length === 1 &&
+        isEndOfRule &&
+        expectTokAfterLastMatch === undefined) {
+        expectTokAfterLastMatch = EOF;
+        nextTokIdx = 1;
+    }
+    if (this.shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck)) {
+        // TODO: performance optimization: instead of passing the original args here, we modify
+        // the args param (or create a new one) and make sure the lookahead func is explicitly provided
+        // to avoid searching the cache for it once more.
+        this.tryInRepetitionRecovery(prodFunc, args, lookaheadFunc, expectTokAfterLastMatch);
+    }
+}
+//# sourceMappingURL=recoverable.js.map

package/packages/less/node_modules/chevrotain/lib_esm/src/parse/parser/traits/tree_builder.js

@@ -0,0 +1,288 @@
+import { addNoneTerminalToCst, addTerminalToCst, setNodeLocationFull, setNodeLocationOnlyOffset } from "../../cst/cst";
+import { has, isUndefined, NOOP } from "../../../utils/utils";
+import { createBaseSemanticVisitorConstructor, createBaseVisitorConstructorWithDefaults } from "../../cst/cst_visitor";
+import { getKeyForAltIndex } from "../../grammar/keys";
+import { DEFAULT_PARSER_CONFIG } from "../parser";
+/**
+ * This trait is responsible for the CST building logic.
+ */
+var TreeBuilder = /** @class */ (function () {
+    function TreeBuilder() {
+    }
+    TreeBuilder.prototype.initTreeBuilder = function (config) {
+        this.LAST_EXPLICIT_RULE_STACK = [];
+        this.CST_STACK = [];
+        this.outputCst = has(config, "outputCst")
+            ? config.outputCst
+            : DEFAULT_PARSER_CONFIG.outputCst;
+        this.nodeLocationTracking = has(config, "nodeLocationTracking")
+            ? config.nodeLocationTracking
+            : DEFAULT_PARSER_CONFIG.nodeLocationTracking;
+        if (!this.outputCst) {
+            this.cstInvocationStateUpdate = NOOP;
+            this.cstFinallyStateUpdate = NOOP;
+            this.cstPostTerminal = NOOP;
+            this.cstPostNonTerminal = NOOP;
+            this.cstPostRule = NOOP;
+            this.getLastExplicitRuleShortName = this.getLastExplicitRuleShortNameNoCst;
+            this.getPreviousExplicitRuleShortName = this.getPreviousExplicitRuleShortNameNoCst;
+            this.getLastExplicitRuleOccurrenceIndex = this.getLastExplicitRuleOccurrenceIndexNoCst;
+            this.manyInternal = this.manyInternalNoCst;
+            this.orInternal = this.orInternalNoCst;
+            this.optionInternal = this.optionInternalNoCst;
+            this.atLeastOneInternal = this.atLeastOneInternalNoCst;
+            this.manySepFirstInternal = this.manySepFirstInternalNoCst;
+            this.atLeastOneSepFirstInternal = this.atLeastOneSepFirstInternalNoCst;
+        }
+        else {
+            if (/full/i.test(this.nodeLocationTracking)) {
+                if (this.recoveryEnabled) {
+                    this.setNodeLocationFromToken = setNodeLocationFull;
+                    this.setNodeLocationFromNode = setNodeLocationFull;
+                    this.cstPostRule = NOOP;
+                    this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery;
+                }
+                else {
+                    this.setNodeLocationFromToken = NOOP;
+                    this.setNodeLocationFromNode = NOOP;
+                    this.cstPostRule = this.cstPostRuleFull;
+                    this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular;
+                }
+            }
+            else if (/onlyOffset/i.test(this.nodeLocationTracking)) {
+                if (this.recoveryEnabled) {
+                    this.setNodeLocationFromToken = (setNodeLocationOnlyOffset);
+                    this.setNodeLocationFromNode = (setNodeLocationOnlyOffset);
+                    this.cstPostRule = NOOP;
+                    this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRecovery;
+                }
+                else {
+                    this.setNodeLocationFromToken = NOOP;
+                    this.setNodeLocationFromNode = NOOP;
+                    this.cstPostRule = this.cstPostRuleOnlyOffset;
+                    this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRegular;
+                }
+            }
+            else if (/none/i.test(this.nodeLocationTracking)) {
+                this.setNodeLocationFromToken = NOOP;
+                this.setNodeLocationFromNode = NOOP;
+                this.cstPostRule = NOOP;
+                this.setInitialNodeLocation = NOOP;
+            }
+            else {
+                throw Error("Invalid <nodeLocationTracking> config option: \"" + config.nodeLocationTracking + "\"");
+            }
+        }
+    };
+    TreeBuilder.prototype.setInitialNodeLocationOnlyOffsetRecovery = function (cstNode) {
+        cstNode.location = {
+            startOffset: NaN,
+            endOffset: NaN
+        };
+    };
+    TreeBuilder.prototype.setInitialNodeLocationOnlyOffsetRegular = function (cstNode) {
+        cstNode.location = {
+            // without error recovery the starting Location of a new CstNode is guaranteed
+            // To be the next Token's startOffset (for valid inputs).
+            // For invalid inputs there won't be any CSTOutput so this potential
+            // inaccuracy does not matter
+            startOffset: this.LA(1).startOffset,
+            endOffset: NaN
+        };
+    };
+    TreeBuilder.prototype.setInitialNodeLocationFullRecovery = function (cstNode) {
+        cstNode.location = {
+            startOffset: NaN,
+            startLine: NaN,
+            startColumn: NaN,
+            endOffset: NaN,
+            endLine: NaN,
+            endColumn: NaN
+        };
+    };
+    /**
+     *  @see setInitialNodeLocationOnlyOffsetRegular for explanation why this work
+
+     * @param cstNode
+     */
+    TreeBuilder.prototype.setInitialNodeLocationFullRegular = function (cstNode) {
+        var nextToken = this.LA(1);
+        cstNode.location = {
+            startOffset: nextToken.startOffset,
+            startLine: nextToken.startLine,
+            startColumn: nextToken.startColumn,
+            endOffset: NaN,
+            endLine: NaN,
+            endColumn: NaN
+        };
+    };
+    // CST
+    TreeBuilder.prototype.cstNestedInvocationStateUpdate = function (nestedName, shortName) {
+        var cstNode = {
+            name: nestedName,
+            fullName: this.shortRuleNameToFull[this.getLastExplicitRuleShortName()] +
+                nestedName,
+            children: {}
+        };
+        this.setInitialNodeLocation(cstNode);
+        this.CST_STACK.push(cstNode);
+    };
+    TreeBuilder.prototype.cstInvocationStateUpdate = function (fullRuleName, shortName) {
+        this.LAST_EXPLICIT_RULE_STACK.push(this.RULE_STACK.length - 1);
+        var cstNode = {
+            name: fullRuleName,
+            children: {}
+        };
+        this.setInitialNodeLocation(cstNode);
+        this.CST_STACK.push(cstNode);
+    };
+    TreeBuilder.prototype.cstFinallyStateUpdate = function () {
+        this.LAST_EXPLICIT_RULE_STACK.pop();
+        this.CST_STACK.pop();
+    };
+    TreeBuilder.prototype.cstNestedFinallyStateUpdate = function () {
+        var lastCstNode = this.CST_STACK.pop();
+        // TODO: the naming is bad, this should go directly to the
+        //       (correct) cstLocation update method
+        //       e.g if we put other logic in postRule...
+        this.cstPostRule(lastCstNode);
+    };
+    TreeBuilder.prototype.cstPostRuleFull = function (ruleCstNode) {
+        var prevToken = this.LA(0);
+        var loc = ruleCstNode.location;
+        // If this condition is true it means we consumed at least one Token
+        // In this CstNode or its nested children.
+        if (loc.startOffset <= prevToken.startOffset === true) {
+            loc.endOffset = prevToken.endOffset;
+            loc.endLine = prevToken.endLine;
+            loc.endColumn = prevToken.endColumn;
+        }
+        // "empty" CstNode edge case
+        else {
+            loc.startOffset = NaN;
+            loc.startLine = NaN;
+            loc.startColumn = NaN;
+        }
+    };
+    TreeBuilder.prototype.cstPostRuleOnlyOffset = function (ruleCstNode) {
+        var prevToken = this.LA(0);
+        var loc = ruleCstNode.location;
+        // If this condition is true it means we consumed at least one Token
+        // In this CstNode or its nested children.
+        if (loc.startOffset <= prevToken.startOffset === true) {
+            loc.endOffset = prevToken.endOffset;
+        }
+        // "empty" CstNode edge case
+        else {
+            loc.startOffset = NaN;
+        }
+    };
+    TreeBuilder.prototype.cstPostTerminal = function (key, consumedToken) {
+        var rootCst = this.CST_STACK[this.CST_STACK.length - 1];
+        addTerminalToCst(rootCst, consumedToken, key);
+        // This is only used when **both** error recovery and CST Output are enabled.
+        this.setNodeLocationFromToken(rootCst.location, consumedToken);
+    };
+    TreeBuilder.prototype.cstPostNonTerminal = function (ruleCstResult, ruleName) {
+        // Avoid side effects due to back tracking
+        // TODO: This costs a 2-3% in performance, A flag on IParserConfig
+        //   could be used to get rid of this conditional, but not sure its worth the effort
+        //   and API complexity.
+        if (this.isBackTracking() !== true) {
+            var preCstNode = this.CST_STACK[this.CST_STACK.length - 1];
+            addNoneTerminalToCst(preCstNode, ruleName, ruleCstResult);
+            // This is only used when **both** error recovery and CST Output are enabled.
+            this.setNodeLocationFromNode(preCstNode.location, ruleCstResult.location);
+        }
+    };
+    TreeBuilder.prototype.getBaseCstVisitorConstructor = function () {
+        if (isUndefined(this.baseCstVisitorConstructor)) {
+            var newBaseCstVisitorConstructor = createBaseSemanticVisitorConstructor(this.className, this.allRuleNames);
+            this.baseCstVisitorConstructor = newBaseCstVisitorConstructor;
+            return newBaseCstVisitorConstructor;
+        }
+        return this.baseCstVisitorConstructor;
+    };
+    TreeBuilder.prototype.getBaseCstVisitorConstructorWithDefaults = function () {
+        if (isUndefined(this.baseCstVisitorWithDefaultsConstructor)) {
+            var newConstructor = createBaseVisitorConstructorWithDefaults(this.className, this.allRuleNames, this.getBaseCstVisitorConstructor());
+            this.baseCstVisitorWithDefaultsConstructor = newConstructor;
+            return newConstructor;
+        }
+        return this.baseCstVisitorWithDefaultsConstructor;
+    };
+    TreeBuilder.prototype.nestedRuleBeforeClause = function (methodOpts, laKey) {
+        var nestedName;
+        if (methodOpts.NAME !== undefined) {
+            nestedName = methodOpts.NAME;
+            this.nestedRuleInvocationStateUpdate(nestedName, laKey);
+            return nestedName;
+        }
+        else {
+            return undefined;
+        }
+    };
+    TreeBuilder.prototype.nestedAltBeforeClause = function (methodOpts, occurrence, methodKeyIdx, altIdx) {
+        var ruleIdx = this.getLastExplicitRuleShortName();
+        var shortName = getKeyForAltIndex(ruleIdx, methodKeyIdx, occurrence, altIdx);
+        var nestedName;
+        if (methodOpts.NAME !== undefined) {
+            nestedName = methodOpts.NAME;
+            this.nestedRuleInvocationStateUpdate(nestedName, shortName);
+            return {
+                shortName: shortName,
+                nestedName: nestedName
+            };
+        }
+        else {
+            return undefined;
+        }
+    };
+    TreeBuilder.prototype.nestedRuleFinallyClause = function (laKey, nestedName) {
+        var cstStack = this.CST_STACK;
+        var nestedRuleCst = cstStack[cstStack.length - 1];
+        this.nestedRuleFinallyStateUpdate();
+        // this return a different result than the previous invocation because "nestedRuleFinallyStateUpdate" pops the cst stack
+        var parentCstNode = cstStack[cstStack.length - 1];
+        addNoneTerminalToCst(parentCstNode, nestedName, nestedRuleCst);
+        this.setNodeLocationFromNode(parentCstNode.location, nestedRuleCst.location);
+    };
+    TreeBuilder.prototype.getLastExplicitRuleShortName = function () {
+        var lastExplictIndex = this.LAST_EXPLICIT_RULE_STACK[this.LAST_EXPLICIT_RULE_STACK.length - 1];
+        return this.RULE_STACK[lastExplictIndex];
+    };
+    TreeBuilder.prototype.getLastExplicitRuleShortNameNoCst = function () {
+        var ruleStack = this.RULE_STACK;
+        return ruleStack[ruleStack.length - 1];
+    };
+    TreeBuilder.prototype.getPreviousExplicitRuleShortName = function () {
+        var lastExplicitIndex = this.LAST_EXPLICIT_RULE_STACK[this.LAST_EXPLICIT_RULE_STACK.length - 2];
+        return this.RULE_STACK[lastExplicitIndex];
+    };
+    TreeBuilder.prototype.getPreviousExplicitRuleShortNameNoCst = function () {
+        var ruleStack = this.RULE_STACK;
+        return ruleStack[ruleStack.length - 2];
+    };
+    TreeBuilder.prototype.getLastExplicitRuleOccurrenceIndex = function () {
+        var lastExplicitIndex = this.LAST_EXPLICIT_RULE_STACK[this.LAST_EXPLICIT_RULE_STACK.length - 1];
+        return this.RULE_OCCURRENCE_STACK[lastExplicitIndex];
+    };
+    TreeBuilder.prototype.getLastExplicitRuleOccurrenceIndexNoCst = function () {
+        var occurrenceStack = this.RULE_OCCURRENCE_STACK;
+        return occurrenceStack[occurrenceStack.length - 1];
+    };
+    TreeBuilder.prototype.nestedRuleInvocationStateUpdate = function (nestedRuleName, shortNameKey) {
+        this.RULE_OCCURRENCE_STACK.push(1);
+        this.RULE_STACK.push(shortNameKey);
+        this.cstNestedInvocationStateUpdate(nestedRuleName, shortNameKey);
+    };
+    TreeBuilder.prototype.nestedRuleFinallyStateUpdate = function () {
+        this.RULE_STACK.pop();
+        this.RULE_OCCURRENCE_STACK.pop();
+        // NOOP when cst is disabled
+        this.cstNestedFinallyStateUpdate();
+    };
+    return TreeBuilder;
+}());
+export { TreeBuilder };
+//# sourceMappingURL=tree_builder.js.map