OR rule follow a NonTerminal with OR rule will fail?

start -> A | B A -> a | b B -> c | d | e

const {createToken, Lexer, Parser, EOF} = require('chevrotain');
const util = require('util');
const a = createToken({name: 'a', pattern: /a/});
const b = createToken({name: 'b', pattern: /b/});
const c = createToken({name: 'c', pattern: /c/});
const d = createToken({name: 'd', pattern: /d/});
const e = createToken({name: 'e', pattern: /e/});
let allTokens = [
    a, b, c, d, e, EOF
];

class UserParser extends Parser {
    constructor(input) {
        super(input, allTokens);
        const $ = this;
        $.RULE('start', () => {
            return $.OR([
                {ALT: () => $.SUBRULE($.A)},
                {ALT: () => $.SUBRULE($.B)}
            ]);
        });
        $.RULE('A', () => {
            return $.OR([
                {ALT: () => $.CONSUME(a)},
                {ALT: () => $.CONSUME(b)}
            ]);
        });
        $.RULE('B', () => {
            return $.OR([
                {ALT: () => $.CONSUME(c)},
                {ALT: () => $.CONSUME(d)},
                {ALT: () => $.CONSUME(e)}
            ]);
        });
    }
}

let lexer = new Lexer(allTokens);

const parser = new UserParser([]);

// ONLY ONCE


function parseInput(text) {
    const lexingResult = lexer.tokenize(text);
    parser.input = lexingResult.tokens;
    let ast = parser.start();
    if (parser.errors.length > 0) {
        for (let i = 0; i < parser.errors.length; i++) {
            console.log(parser.errors[i]);
        }
    }
    return ast;
}

const inputText = "c";
let json = parseInput(inputText);
console.log(util.inspect(json, {depth: null, colors: "auto"}));

Error MESSAGE: [NoViableAltException: Expecting: one of these possible Token sequences:

1. [a]
2. [b] but found: ‘c’] How can i solve this problem without modify my grammar.

[bd82]

It seems you forgot to call this.performSelfAnalysis() See: https://github.com/SAP/chevrotain/blob/master/examples/grammars/json/json.js#L107-L110

I am leaving this issue open to think again if I can detect the lack of this call and produce a clear error message without suffering from a performance penalty.

[bd82]

Looks like even when using a NOOP pattern there is still some performance regression.

    private checkStaticAnalysis() {
        if (this.selfAnalysisDone === false) {
            throw Error("Oops I did it again!")
        }
        else {
            this.checkStaticAnalysis = NOOP
        }
    }

I suppose the documentation would have to suffice for now.