@windrun-huaiin/third-ui 12.1.0 → 13.0.1

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/checks.js

@@ -0,0 +1,469 @@
+'use strict';
+
+var parser = require('../parser/parser.js');
+var model = require('../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.js');
+var visitor = require('../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/visitor.js');
+var helpers = require('../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/helpers.js');
+var lookahead = require('./lookahead.js');
+var interpreter = require('./interpreter.js');
+var tokens = require('../../scan/tokens.js');
+var forEach = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.js');
+var isEmpty = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isEmpty.js');
+var flatten = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/flatten.js');
+var map = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/map.js');
+var flatMap = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/flatMap.js');
+var groupBy = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/groupBy.js');
+var pickBy = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/pickBy.js');
+var head = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/head.js');
+var values = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/values.js');
+var includes = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/includes.js');
+var reduce = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/reduce.js');
+var difference = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/difference.js');
+var clone = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/clone.js');
+var dropRight = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/dropRight.js');
+var reject = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/reject.js');
+var drop = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/drop.js');
+var compact = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/compact.js');
+var filter = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/filter.js');
+
+function validateLookahead(options) {
+    const lookaheadValidationErrorMessages = options.lookaheadStrategy.validate({
+        rules: options.rules,
+        tokenTypes: options.tokenTypes,
+        grammarName: options.grammarName,
+    });
+    return map(lookaheadValidationErrorMessages, (errorMessage) => (Object.assign({ type: parser.ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, errorMessage)));
+}
+function validateGrammar(topLevels, tokenTypes, errMsgProvider, grammarName) {
+    const duplicateErrors = flatMap(topLevels, (currTopLevel) => validateDuplicateProductions(currTopLevel, errMsgProvider));
+    const termsNamespaceConflictErrors = checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider);
+    const tooManyAltsErrors = flatMap(topLevels, (curRule) => validateTooManyAlts(curRule, errMsgProvider));
+    const duplicateRulesError = flatMap(topLevels, (curRule) => validateRuleDoesNotAlreadyExist(curRule, topLevels, grammarName, errMsgProvider));
+    return duplicateErrors.concat(termsNamespaceConflictErrors, tooManyAltsErrors, duplicateRulesError);
+}
+function validateDuplicateProductions(topLevelRule, errMsgProvider) {
+    const collectorVisitor = new OccurrenceValidationCollector();
+    topLevelRule.accept(collectorVisitor);
+    const allRuleProductions = collectorVisitor.allProductions;
+    const productionGroups = groupBy(allRuleProductions, identifyProductionForDuplicates);
+    const duplicates = pickBy(productionGroups, (currGroup) => {
+        return currGroup.length > 1;
+    });
+    const errors = map(values(duplicates), (currDuplicates) => {
+        const firstProd = head(currDuplicates);
+        const msg = errMsgProvider.buildDuplicateFoundError(topLevelRule, currDuplicates);
+        const dslName = helpers.getProductionDslName(firstProd);
+        const defError = {
+            message: msg,
+            type: parser.ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
+            ruleName: topLevelRule.name,
+            dslName: dslName,
+            occurrence: firstProd.idx,
+        };
+        const param = getExtraProductionArgument(firstProd);
+        if (param) {
+            defError.parameter = param;
+        }
+        return defError;
+    });
+    return errors;
+}
+function identifyProductionForDuplicates(prod) {
+    return `${helpers.getProductionDslName(prod)}_#_${prod.idx}_#_${getExtraProductionArgument(prod)}`;
+}
+function getExtraProductionArgument(prod) {
+    if (prod instanceof model.Terminal) {
+        return prod.terminalType.name;
+    }
+    else if (prod instanceof model.NonTerminal) {
+        return prod.nonTerminalName;
+    }
+    else {
+        return "";
+    }
+}
+class OccurrenceValidationCollector extends visitor.GAstVisitor {
+    constructor() {
+        super(...arguments);
+        this.allProductions = [];
+    }
+    visitNonTerminal(subrule) {
+        this.allProductions.push(subrule);
+    }
+    visitOption(option) {
+        this.allProductions.push(option);
+    }
+    visitRepetitionWithSeparator(manySep) {
+        this.allProductions.push(manySep);
+    }
+    visitRepetitionMandatory(atLeastOne) {
+        this.allProductions.push(atLeastOne);
+    }
+    visitRepetitionMandatoryWithSeparator(atLeastOneSep) {
+        this.allProductions.push(atLeastOneSep);
+    }
+    visitRepetition(many) {
+        this.allProductions.push(many);
+    }
+    visitAlternation(or) {
+        this.allProductions.push(or);
+    }
+    visitTerminal(terminal) {
+        this.allProductions.push(terminal);
+    }
+}
+function validateRuleDoesNotAlreadyExist(rule, allRules, className, errMsgProvider) {
+    const errors = [];
+    const occurrences = reduce(allRules, (result, curRule) => {
+        if (curRule.name === rule.name) {
+            return result + 1;
+        }
+        return result;
+    }, 0);
+    if (occurrences > 1) {
+        const errMsg = errMsgProvider.buildDuplicateRuleNameError({
+            topLevelRule: rule,
+            grammarName: className,
+        });
+        errors.push({
+            message: errMsg,
+            type: parser.ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
+            ruleName: rule.name,
+        });
+    }
+    return errors;
+}
+// TODO: is there anyway to get only the rule names of rules inherited from the super grammars?
+// This is not part of the IGrammarErrorProvider because the validation cannot be performed on
+// The grammar structure, only at runtime.
+function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
+    const errors = [];
+    let errMsg;
+    if (!includes(definedRulesNames, ruleName)) {
+        errMsg =
+            `Invalid rule override, rule: ->${ruleName}<- cannot be overridden in the grammar: ->${className}<-` +
+                `as it is not defined in any of the super grammars `;
+        errors.push({
+            message: errMsg,
+            type: parser.ParserDefinitionErrorType.INVALID_RULE_OVERRIDE,
+            ruleName: ruleName,
+        });
+    }
+    return errors;
+}
+function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path = []) {
+    const errors = [];
+    const nextNonTerminals = getFirstNoneTerminal(currRule.definition);
+    if (isEmpty(nextNonTerminals)) {
+        return [];
+    }
+    else {
+        const ruleName = topRule.name;
+        const foundLeftRecursion = includes(nextNonTerminals, topRule);
+        if (foundLeftRecursion) {
+            errors.push({
+                message: errMsgProvider.buildLeftRecursionError({
+                    topLevelRule: topRule,
+                    leftRecursionPath: path,
+                }),
+                type: parser.ParserDefinitionErrorType.LEFT_RECURSION,
+                ruleName: ruleName,
+            });
+        }
+        // we are only looking for cyclic paths leading back to the specific topRule
+        // other cyclic paths are ignored, we still need this difference to avoid infinite loops...
+        const validNextSteps = difference(nextNonTerminals, path.concat([topRule]));
+        const errorsFromNextSteps = flatMap(validNextSteps, (currRefRule) => {
+            const newPath = clone(path);
+            newPath.push(currRefRule);
+            return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
+        });
+        return errors.concat(errorsFromNextSteps);
+    }
+}
+function getFirstNoneTerminal(definition) {
+    let result = [];
+    if (isEmpty(definition)) {
+        return result;
+    }
+    const firstProd = head(definition);
+    /* istanbul ignore else */
+    if (firstProd instanceof model.NonTerminal) {
+        result.push(firstProd.referencedRule);
+    }
+    else if (firstProd instanceof model.Alternative ||
+        firstProd instanceof model.Option ||
+        firstProd instanceof model.RepetitionMandatory ||
+        firstProd instanceof model.RepetitionMandatoryWithSeparator ||
+        firstProd instanceof model.RepetitionWithSeparator ||
+        firstProd instanceof model.Repetition) {
+        result = result.concat(getFirstNoneTerminal(firstProd.definition));
+    }
+    else if (firstProd instanceof model.Alternation) {
+        // each sub definition in alternation is a FLAT
+        result = flatten(map(firstProd.definition, (currSubDef) => getFirstNoneTerminal(currSubDef.definition)));
+    }
+    else if (firstProd instanceof model.Terminal) ;
+    else {
+        throw Error("non exhaustive match");
+    }
+    const isFirstOptional = helpers.isOptionalProd(firstProd);
+    const hasMore = definition.length > 1;
+    if (isFirstOptional && hasMore) {
+        const rest = drop(definition);
+        return result.concat(getFirstNoneTerminal(rest));
+    }
+    else {
+        return result;
+    }
+}
+class OrCollector extends visitor.GAstVisitor {
+    constructor() {
+        super(...arguments);
+        this.alternations = [];
+    }
+    visitAlternation(node) {
+        this.alternations.push(node);
+    }
+}
+function validateEmptyOrAlternative(topLevelRule, errMsgProvider) {
+    const orCollector = new OrCollector();
+    topLevelRule.accept(orCollector);
+    const ors = orCollector.alternations;
+    const errors = flatMap(ors, (currOr) => {
+        const exceptLast = dropRight(currOr.definition);
+        return flatMap(exceptLast, (currAlternative, currAltIdx) => {
+            const possibleFirstInAlt = interpreter.nextPossibleTokensAfter([currAlternative], [], tokens.tokenStructuredMatcher, 1);
+            if (isEmpty(possibleFirstInAlt)) {
+                return [
+                    {
+                        message: errMsgProvider.buildEmptyAlternationError({
+                            topLevelRule: topLevelRule,
+                            alternation: currOr,
+                            emptyChoiceIdx: currAltIdx,
+                        }),
+                        type: parser.ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,
+                        ruleName: topLevelRule.name,
+                        occurrence: currOr.idx,
+                        alternative: currAltIdx + 1,
+                    },
+                ];
+            }
+            else {
+                return [];
+            }
+        });
+    });
+    return errors;
+}
+function validateAmbiguousAlternationAlternatives(topLevelRule, globalMaxLookahead, errMsgProvider) {
+    const orCollector = new OrCollector();
+    topLevelRule.accept(orCollector);
+    let ors = orCollector.alternations;
+    // New Handling of ignoring ambiguities
+    // - https://github.com/chevrotain/chevrotain/issues/869
+    ors = reject(ors, (currOr) => currOr.ignoreAmbiguities === true);
+    const errors = flatMap(ors, (currOr) => {
+        const currOccurrence = currOr.idx;
+        const actualMaxLookahead = currOr.maxLookahead || globalMaxLookahead;
+        const alternatives = lookahead.getLookaheadPathsForOr(currOccurrence, topLevelRule, actualMaxLookahead, currOr);
+        const altsAmbiguityErrors = checkAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);
+        const altsPrefixAmbiguityErrors = checkPrefixAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);
+        return altsAmbiguityErrors.concat(altsPrefixAmbiguityErrors);
+    });
+    return errors;
+}
+class RepetitionCollector extends visitor.GAstVisitor {
+    constructor() {
+        super(...arguments);
+        this.allProductions = [];
+    }
+    visitRepetitionWithSeparator(manySep) {
+        this.allProductions.push(manySep);
+    }
+    visitRepetitionMandatory(atLeastOne) {
+        this.allProductions.push(atLeastOne);
+    }
+    visitRepetitionMandatoryWithSeparator(atLeastOneSep) {
+        this.allProductions.push(atLeastOneSep);
+    }
+    visitRepetition(many) {
+        this.allProductions.push(many);
+    }
+}
+function validateTooManyAlts(topLevelRule, errMsgProvider) {
+    const orCollector = new OrCollector();
+    topLevelRule.accept(orCollector);
+    const ors = orCollector.alternations;
+    const errors = flatMap(ors, (currOr) => {
+        if (currOr.definition.length > 255) {
+            return [
+                {
+                    message: errMsgProvider.buildTooManyAlternativesError({
+                        topLevelRule: topLevelRule,
+                        alternation: currOr,
+                    }),
+                    type: parser.ParserDefinitionErrorType.TOO_MANY_ALTS,
+                    ruleName: topLevelRule.name,
+                    occurrence: currOr.idx,
+                },
+            ];
+        }
+        else {
+            return [];
+        }
+    });
+    return errors;
+}
+function validateSomeNonEmptyLookaheadPath(topLevelRules, maxLookahead, errMsgProvider) {
+    const errors = [];
+    forEach(topLevelRules, (currTopRule) => {
+        const collectorVisitor = new RepetitionCollector();
+        currTopRule.accept(collectorVisitor);
+        const allRuleProductions = collectorVisitor.allProductions;
+        forEach(allRuleProductions, (currProd) => {
+            const prodType = lookahead.getProdType(currProd);
+            const actualMaxLookahead = currProd.maxLookahead || maxLookahead;
+            const currOccurrence = currProd.idx;
+            const paths = lookahead.getLookaheadPathsForOptionalProd(currOccurrence, currTopRule, prodType, actualMaxLookahead);
+            const pathsInsideProduction = paths[0];
+            if (isEmpty(flatten(pathsInsideProduction))) {
+                const errMsg = errMsgProvider.buildEmptyRepetitionError({
+                    topLevelRule: currTopRule,
+                    repetition: currProd,
+                });
+                errors.push({
+                    message: errMsg,
+                    type: parser.ParserDefinitionErrorType.NO_NON_EMPTY_LOOKAHEAD,
+                    ruleName: currTopRule.name,
+                });
+            }
+        });
+    });
+    return errors;
+}
+function checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
+    const foundAmbiguousPaths = [];
+    const identicalAmbiguities = reduce(alternatives, (result, currAlt, currAltIdx) => {
+        // ignore (skip) ambiguities with this alternative
+        if (alternation.definition[currAltIdx].ignoreAmbiguities === true) {
+            return result;
+        }
+        forEach(currAlt, (currPath) => {
+            const altsCurrPathAppearsIn = [currAltIdx];
+            forEach(alternatives, (currOtherAlt, currOtherAltIdx) => {
+                if (currAltIdx !== currOtherAltIdx &&
+                    lookahead.containsPath(currOtherAlt, currPath) &&
+                    // ignore (skip) ambiguities with this "other" alternative
+                    alternation.definition[currOtherAltIdx].ignoreAmbiguities !== true) {
+                    altsCurrPathAppearsIn.push(currOtherAltIdx);
+                }
+            });
+            if (altsCurrPathAppearsIn.length > 1 &&
+                !lookahead.containsPath(foundAmbiguousPaths, currPath)) {
+                foundAmbiguousPaths.push(currPath);
+                result.push({
+                    alts: altsCurrPathAppearsIn,
+                    path: currPath,
+                });
+            }
+        });
+        return result;
+    }, []);
+    const currErrors = map(identicalAmbiguities, (currAmbDescriptor) => {
+        const ambgIndices = map(currAmbDescriptor.alts, (currAltIdx) => currAltIdx + 1);
+        const currMessage = errMsgProvider.buildAlternationAmbiguityError({
+            topLevelRule: rule,
+            alternation: alternation,
+            ambiguityIndices: ambgIndices,
+            prefixPath: currAmbDescriptor.path,
+        });
+        return {
+            message: currMessage,
+            type: parser.ParserDefinitionErrorType.AMBIGUOUS_ALTS,
+            ruleName: rule.name,
+            occurrence: alternation.idx,
+            alternatives: currAmbDescriptor.alts,
+        };
+    });
+    return currErrors;
+}
+function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
+    // flatten
+    const pathsAndIndices = reduce(alternatives, (result, currAlt, idx) => {
+        const currPathsAndIdx = map(currAlt, (currPath) => {
+            return { idx: idx, path: currPath };
+        });
+        return result.concat(currPathsAndIdx);
+    }, []);
+    const errors = compact(flatMap(pathsAndIndices, (currPathAndIdx) => {
+        const alternativeGast = alternation.definition[currPathAndIdx.idx];
+        // ignore (skip) ambiguities with this alternative
+        if (alternativeGast.ignoreAmbiguities === true) {
+            return [];
+        }
+        const targetIdx = currPathAndIdx.idx;
+        const targetPath = currPathAndIdx.path;
+        const prefixAmbiguitiesPathsAndIndices = filter(pathsAndIndices, (searchPathAndIdx) => {
+            // prefix ambiguity can only be created from lower idx (higher priority) path
+            return (
+            // ignore (skip) ambiguities with this "other" alternative
+            alternation.definition[searchPathAndIdx.idx].ignoreAmbiguities !==
+                true &&
+                searchPathAndIdx.idx < targetIdx &&
+                // checking for strict prefix because identical lookaheads
+                // will be be detected using a different validation.
+                lookahead.isStrictPrefixOfPath(searchPathAndIdx.path, targetPath));
+        });
+        const currPathPrefixErrors = map(prefixAmbiguitiesPathsAndIndices, (currAmbPathAndIdx) => {
+            const ambgIndices = [currAmbPathAndIdx.idx + 1, targetIdx + 1];
+            const occurrence = alternation.idx === 0 ? "" : alternation.idx;
+            const message = errMsgProvider.buildAlternationPrefixAmbiguityError({
+                topLevelRule: rule,
+                alternation: alternation,
+                ambiguityIndices: ambgIndices,
+                prefixPath: currAmbPathAndIdx.path,
+            });
+            return {
+                message: message,
+                type: parser.ParserDefinitionErrorType.AMBIGUOUS_PREFIX_ALTS,
+                ruleName: rule.name,
+                occurrence: occurrence,
+                alternatives: ambgIndices,
+            };
+        });
+        return currPathPrefixErrors;
+    }));
+    return errors;
+}
+function checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider) {
+    const errors = [];
+    const tokenNames = map(tokenTypes, (currToken) => currToken.name);
+    forEach(topLevels, (currRule) => {
+        const currRuleName = currRule.name;
+        if (includes(tokenNames, currRuleName)) {
+            const errMsg = errMsgProvider.buildNamespaceConflictError(currRule);
+            errors.push({
+                message: errMsg,
+                type: parser.ParserDefinitionErrorType.CONFLICT_TOKENS_RULES_NAMESPACE,
+                ruleName: currRuleName,
+            });
+        }
+    });
+    return errors;
+}
+
+exports.OccurrenceValidationCollector = OccurrenceValidationCollector;
+exports.RepetitionCollector = RepetitionCollector;
+exports.checkPrefixAlternativesAmbiguities = checkPrefixAlternativesAmbiguities;
+exports.getFirstNoneTerminal = getFirstNoneTerminal;
+exports.identifyProductionForDuplicates = identifyProductionForDuplicates;
+exports.validateAmbiguousAlternationAlternatives = validateAmbiguousAlternationAlternatives;
+exports.validateEmptyOrAlternative = validateEmptyOrAlternative;
+exports.validateGrammar = validateGrammar;
+exports.validateLookahead = validateLookahead;
+exports.validateNoLeftRecursion = validateNoLeftRecursion;
+exports.validateRuleDoesNotAlreadyExist = validateRuleDoesNotAlreadyExist;
+exports.validateRuleIsOverridden = validateRuleIsOverridden;
+exports.validateSomeNonEmptyLookaheadPath = validateSomeNonEmptyLookaheadPath;
+exports.validateTooManyAlts = validateTooManyAlts;