@informalsystems/quint/dist/src/generated/EffectParser.js

Core tool for the Quint specification language

"use strict";
// Generated from ./src/generated/Effect.g4 by ANTLR 4.9.0-SNAPSHOT
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.StateVarRefContext = exports.EntityContext = exports.PureContext = exports.ReadAndTemporalContext = exports.ReadAndUpdateContext = exports.TemporalOnlyContext = exports.UpdateOnlyContext = exports.ReadOnlyContext = exports.ConcreteContext = exports.TemporalContext = exports.UpdateContext = exports.ReadContext = exports.VariableEffectContext = exports.ArrowEffectContext = exports.ConcreteEffectContext = exports.EffectContext = exports.EffectParser = void 0;
const ATNDeserializer_1 = require("antlr4ts/atn/ATNDeserializer");
const FailedPredicateException_1 = require("antlr4ts/FailedPredicateException");
const NoViableAltException_1 = require("antlr4ts/NoViableAltException");
const Parser_1 = require("antlr4ts/Parser");
const ParserRuleContext_1 = require("antlr4ts/ParserRuleContext");
const ParserATNSimulator_1 = require("antlr4ts/atn/ParserATNSimulator");
const RecognitionException_1 = require("antlr4ts/RecognitionException");
const VocabularyImpl_1 = require("antlr4ts/VocabularyImpl");
const Utils = __importStar(require("antlr4ts/misc/Utils"));
class EffectParser extends Parser_1.Parser {
    // @Override
    // @NotNull
    get vocabulary() {
        return EffectParser.VOCABULARY;
    }
    // tslint:enable:no-trailing-whitespace
    // @Override
    get grammarFileName() { return "Effect.g4"; }
    // @Override
    get ruleNames() { return EffectParser.ruleNames; }
    // @Override
    get serializedATN() { return EffectParser._serializedATN; }
    createFailedPredicateException(predicate, message) {
        return new FailedPredicateException_1.FailedPredicateException(this, predicate, message);
    }
    constructor(input) {
        super(input);
        this._interp = new ParserATNSimulator_1.ParserATNSimulator(EffectParser._ATN, this);
    }
    // @RuleVersion(0)
    effect() {
        let _localctx = new EffectContext(this._ctx, this.state);
        this.enterRule(_localctx, 0, EffectParser.RULE_effect);
        let _la;
        try {
            this.state = 30;
            this._errHandler.sync(this);
            switch (this._input.LA(1)) {
                case EffectParser.T__4:
                case EffectParser.T__7:
                case EffectParser.T__8:
                case EffectParser.T__10:
                    _localctx = new ConcreteEffectContext(_localctx);
                    this.enterOuterAlt(_localctx, 1);
                    {
                        this.state = 14;
                        this.concrete();
                    }
                    break;
                case EffectParser.T__0:
                    _localctx = new ArrowEffectContext(_localctx);
                    this.enterOuterAlt(_localctx, 2);
                    {
                        this.state = 15;
                        this.match(EffectParser.T__0);
                        this.state = 24;
                        this._errHandler.sync(this);
                        _la = this._input.LA(1);
                        if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << EffectParser.T__0) | (1 << EffectParser.T__4) | (1 << EffectParser.T__7) | (1 << EffectParser.T__8) | (1 << EffectParser.T__10) | (1 << EffectParser.IDENTIFIER))) !== 0)) {
                            {
                                this.state = 16;
                                this.effect();
                                this.state = 21;
                                this._errHandler.sync(this);
                                _la = this._input.LA(1);
                                while (_la === EffectParser.T__1) {
                                    {
                                        {
                                            this.state = 17;
                                            this.match(EffectParser.T__1);
                                            this.state = 18;
                                            this.effect();
                                        }
                                    }
                                    this.state = 23;
                                    this._errHandler.sync(this);
                                    _la = this._input.LA(1);
                                }
                            }
                        }
                        this.state = 26;
                        this.match(EffectParser.T__2);
                        this.state = 27;
                        this.match(EffectParser.T__3);
                        this.state = 28;
                        this.effect();
                    }
                    break;
                case EffectParser.IDENTIFIER:
                    _localctx = new VariableEffectContext(_localctx);
                    this.enterOuterAlt(_localctx, 3);
                    {
                        this.state = 29;
                        this.match(EffectParser.IDENTIFIER);
                    }
                    break;
                default:
                    throw new NoViableAltException_1.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    // @RuleVersion(0)
    read() {
        let _localctx = new ReadContext(this._ctx, this.state);
        this.enterRule(_localctx, 2, EffectParser.RULE_read);
        try {
            this.enterOuterAlt(_localctx, 1);
            {
                this.state = 32;
                this.match(EffectParser.T__4);
                this.state = 33;
                this.match(EffectParser.T__5);
                this.state = 34;
                this.entity();
                this.state = 35;
                this.match(EffectParser.T__6);
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    // @RuleVersion(0)
    update() {
        let _localctx = new UpdateContext(this._ctx, this.state);
        this.enterRule(_localctx, 4, EffectParser.RULE_update);
        try {
            this.enterOuterAlt(_localctx, 1);
            {
                this.state = 37;
                this.match(EffectParser.T__7);
                this.state = 38;
                this.match(EffectParser.T__5);
                this.state = 39;
                this.entity();
                this.state = 40;
                this.match(EffectParser.T__6);
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    // @RuleVersion(0)
    temporal() {
        let _localctx = new TemporalContext(this._ctx, this.state);
        this.enterRule(_localctx, 6, EffectParser.RULE_temporal);
        try {
            this.enterOuterAlt(_localctx, 1);
            {
                this.state = 42;
                this.match(EffectParser.T__8);
                this.state = 43;
                this.match(EffectParser.T__5);
                this.state = 44;
                this.entity();
                this.state = 45;
                this.match(EffectParser.T__6);
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    // @RuleVersion(0)
    concrete() {
        let _localctx = new ConcreteContext(this._ctx, this.state);
        this.enterRule(_localctx, 8, EffectParser.RULE_concrete);
        try {
            this.state = 71;
            this._errHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this._input, 5, this._ctx)) {
                case 1:
                    _localctx = new ReadOnlyContext(_localctx);
                    this.enterOuterAlt(_localctx, 1);
                    {
                        this.state = 47;
                        this.read();
                    }
                    break;
                case 2:
                    _localctx = new UpdateOnlyContext(_localctx);
                    this.enterOuterAlt(_localctx, 2);
                    {
                        this.state = 48;
                        this.update();
                    }
                    break;
                case 3:
                    _localctx = new TemporalOnlyContext(_localctx);
                    this.enterOuterAlt(_localctx, 3);
                    {
                        this.state = 49;
                        this.temporal();
                    }
                    break;
                case 4:
                    _localctx = new ReadAndUpdateContext(_localctx);
                    this.enterOuterAlt(_localctx, 4);
                    {
                        this.state = 58;
                        this._errHandler.sync(this);
                        switch (this._input.LA(1)) {
                            case EffectParser.T__4:
                                {
                                    this.state = 50;
                                    this.read();
                                    this.state = 51;
                                    this.match(EffectParser.T__9);
                                    this.state = 52;
                                    this.update();
                                }
                                break;
                            case EffectParser.T__7:
                                {
                                    this.state = 54;
                                    this.update();
                                    this.state = 55;
                                    this.match(EffectParser.T__9);
                                    this.state = 56;
                                    this.read();
                                }
                                break;
                            default:
                                throw new NoViableAltException_1.NoViableAltException(this);
                        }
                    }
                    break;
                case 5:
                    _localctx = new ReadAndTemporalContext(_localctx);
                    this.enterOuterAlt(_localctx, 5);
                    {
                        this.state = 68;
                        this._errHandler.sync(this);
                        switch (this._input.LA(1)) {
                            case EffectParser.T__4:
                                {
                                    this.state = 60;
                                    this.read();
                                    this.state = 61;
                                    this.match(EffectParser.T__9);
                                    this.state = 62;
                                    this.temporal();
                                }
                                break;
                            case EffectParser.T__7:
                                {
                                    this.state = 64;
                                    this.update();
                                    this.state = 65;
                                    this.match(EffectParser.T__9);
                                    this.state = 66;
                                    this.temporal();
                                }
                                break;
                            default:
                                throw new NoViableAltException_1.NoViableAltException(this);
                        }
                    }
                    break;
                case 6:
                    _localctx = new PureContext(_localctx);
                    this.enterOuterAlt(_localctx, 6);
                    {
                        this.state = 70;
                        this.match(EffectParser.T__10);
                    }
                    break;
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    // @RuleVersion(0)
    entity() {
        let _localctx = new EntityContext(this._ctx, this.state);
        this.enterRule(_localctx, 10, EffectParser.RULE_entity);
        let _la;
        try {
            this.enterOuterAlt(_localctx, 1);
            {
                this.state = 87;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
                if (_la === EffectParser.T__11 || _la === EffectParser.IDENTIFIER) {
                    {
                        this.state = 75;
                        this._errHandler.sync(this);
                        switch (this._input.LA(1)) {
                            case EffectParser.T__11:
                                {
                                    this.state = 73;
                                    this.stateVarRef();
                                }
                                break;
                            case EffectParser.IDENTIFIER:
                                {
                                    this.state = 74;
                                    this.match(EffectParser.IDENTIFIER);
                                }
                                break;
                            default:
                                throw new NoViableAltException_1.NoViableAltException(this);
                        }
                        this.state = 84;
                        this._errHandler.sync(this);
                        _la = this._input.LA(1);
                        while (_la === EffectParser.T__1) {
                            {
                                {
                                    this.state = 77;
                                    this.match(EffectParser.T__1);
                                    this.state = 80;
                                    this._errHandler.sync(this);
                                    switch (this._input.LA(1)) {
                                        case EffectParser.T__11:
                                            {
                                                this.state = 78;
                                                this.stateVarRef();
                                            }
                                            break;
                                        case EffectParser.IDENTIFIER:
                                            {
                                                this.state = 79;
                                                this.match(EffectParser.IDENTIFIER);
                                            }
                                            break;
                                        default:
                                            throw new NoViableAltException_1.NoViableAltException(this);
                                    }
                                }
                            }
                            this.state = 86;
                            this._errHandler.sync(this);
                            _la = this._input.LA(1);
                        }
                    }
                }
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    // @RuleVersion(0)
    stateVarRef() {
        let _localctx = new StateVarRefContext(this._ctx, this.state);
        this.enterRule(_localctx, 12, EffectParser.RULE_stateVarRef);
        try {
            this.enterOuterAlt(_localctx, 1);
            {
                this.state = 89;
                this.match(EffectParser.T__11);
                this.state = 90;
                this.match(EffectParser.IDENTIFIER);
                this.state = 91;
                this.match(EffectParser.T__11);
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    static get _ATN() {
        if (!EffectParser.__ATN) {
            EffectParser.__ATN = new ATNDeserializer_1.ATNDeserializer().deserialize(Utils.toCharArray(EffectParser._serializedATN));
        }
        return EffectParser.__ATN;
    }
}
exports.EffectParser = EffectParser;
EffectParser.T__0 = 1;
EffectParser.T__1 = 2;
EffectParser.T__2 = 3;
EffectParser.T__3 = 4;
EffectParser.T__4 = 5;
EffectParser.T__5 = 6;
EffectParser.T__6 = 7;
EffectParser.T__7 = 8;
EffectParser.T__8 = 9;
EffectParser.T__9 = 10;
EffectParser.T__10 = 11;
EffectParser.T__11 = 12;
EffectParser.IDENTIFIER = 13;
EffectParser.WS = 14;
EffectParser.RULE_effect = 0;
EffectParser.RULE_read = 1;
EffectParser.RULE_update = 2;
EffectParser.RULE_temporal = 3;
EffectParser.RULE_concrete = 4;
EffectParser.RULE_entity = 5;
EffectParser.RULE_stateVarRef = 6;
// tslint:disable:no-trailing-whitespace
EffectParser.ruleNames = [
    "effect", "read", "update", "temporal", "concrete", "entity", "stateVarRef",
];
EffectParser._LITERAL_NAMES = [
    undefined, "'('", "','", "')'", "'=>'", "'Read'", "'['", "']'", "'Update'",
    "'Temporal'", "'&'", "'Pure'", "'''",
];
EffectParser._SYMBOLIC_NAMES = [
    undefined, undefined, undefined, undefined, undefined, undefined, undefined,
    undefined, undefined, undefined, undefined, undefined, undefined, "IDENTIFIER",
    "WS",
];
EffectParser.VOCABULARY = new VocabularyImpl_1.VocabularyImpl(EffectParser._LITERAL_NAMES, EffectParser._SYMBOLIC_NAMES, []);
EffectParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x10`\x04\x02" +
    "\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
    "\t\x07\x04\b\t\b\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x07\x02\x16\n" +
    "\x02\f\x02\x0E\x02\x19\v\x02\x05\x02\x1B\n\x02\x03\x02\x03\x02\x03\x02" +
    "\x03\x02\x05\x02!\n\x02\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x04" +
    "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" +
    "\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06" +
    "\x03\x06\x03\x06\x05\x06=\n\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06" +
    "\x03\x06\x03\x06\x03\x06\x05\x06G\n\x06\x03\x06\x05\x06J\n\x06\x03\x07" +
    "\x03\x07\x05\x07N\n\x07\x03\x07\x03\x07\x03\x07\x05\x07S\n\x07\x07\x07" +
    "U\n\x07\f\x07\x0E\x07X\v\x07\x05\x07Z\n\x07\x03\b\x03\b\x03\b\x03\b\x03" +
    "\b\x02\x02\x02\t\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E\x02\x02" +
    "\x02\x02g\x02 \x03\x02\x02\x02\x04\"\x03\x02\x02\x02\x06\'\x03\x02\x02" +
    "\x02\b,\x03\x02\x02\x02\nI\x03\x02\x02\x02\fY\x03\x02\x02\x02\x0E[\x03" +
    "\x02\x02\x02\x10!\x05\n\x06\x02\x11\x1A\x07\x03\x02\x02\x12\x17\x05\x02" +
    "\x02\x02\x13\x14\x07\x04\x02\x02\x14\x16\x05\x02\x02\x02\x15\x13\x03\x02" +
    "\x02\x02\x16\x19\x03\x02\x02\x02\x17\x15\x03\x02\x02\x02\x17\x18\x03\x02" +
    "\x02\x02\x18\x1B\x03\x02\x02\x02\x19\x17\x03\x02\x02\x02\x1A\x12\x03\x02" +
    "\x02\x02\x1A\x1B\x03\x02\x02\x02\x1B\x1C\x03\x02\x02\x02\x1C\x1D\x07\x05" +
    "\x02\x02\x1D\x1E\x07\x06\x02\x02\x1E!\x05\x02\x02\x02\x1F!\x07\x0F\x02" +
    "\x02 \x10\x03\x02\x02\x02 \x11\x03\x02\x02\x02 \x1F\x03\x02\x02\x02!\x03" +
    "\x03\x02\x02\x02\"#\x07\x07\x02\x02#$\x07\b\x02\x02$%\x05\f\x07\x02%&" +
    "\x07\t\x02\x02&\x05\x03\x02\x02\x02\'(\x07\n\x02\x02()\x07\b\x02\x02)" +
    "*\x05\f\x07\x02*+\x07\t\x02\x02+\x07\x03\x02\x02\x02,-\x07\v\x02\x02-" +
    ".\x07\b\x02\x02./\x05\f\x07\x02/0\x07\t\x02\x020\t\x03\x02\x02\x021J\x05" +
    "\x04\x03\x022J\x05\x06\x04\x023J\x05\b\x05\x0245\x05\x04\x03\x0256\x07" +
    "\f\x02\x0267\x05\x06\x04\x027=\x03\x02\x02\x0289\x05\x06\x04\x029:\x07" +
    "\f\x02\x02:;\x05\x04\x03\x02;=\x03\x02\x02\x02<4\x03\x02\x02\x02<8\x03" +
    "\x02\x02\x02=J\x03\x02\x02\x02>?\x05\x04\x03\x02?@\x07\f\x02\x02@A\x05" +
    "\b\x05\x02AG\x03\x02\x02\x02BC\x05\x06\x04\x02CD\x07\f\x02\x02DE\x05\b" +
    "\x05\x02EG\x03\x02\x02\x02F>\x03\x02\x02\x02FB\x03\x02\x02\x02GJ\x03\x02" +
    "\x02\x02HJ\x07\r\x02\x02I1\x03\x02\x02\x02I2\x03\x02\x02\x02I3\x03\x02" +
    "\x02\x02I<\x03\x02\x02\x02IF\x03\x02\x02\x02IH\x03\x02\x02\x02J\v\x03" +
    "\x02\x02\x02KN\x05\x0E\b\x02LN\x07\x0F\x02\x02MK\x03\x02\x02\x02ML\x03" +
    "\x02\x02\x02NV\x03\x02\x02\x02OR\x07\x04\x02\x02PS\x05\x0E\b\x02QS\x07" +
    "\x0F\x02\x02RP\x03\x02\x02\x02RQ\x03\x02\x02\x02SU\x03\x02\x02\x02TO\x03" +
    "\x02\x02\x02UX\x03\x02\x02\x02VT\x03\x02\x02\x02VW\x03\x02\x02\x02WZ\x03" +
    "\x02\x02\x02XV\x03\x02\x02\x02YM\x03\x02\x02\x02YZ\x03\x02\x02\x02Z\r" +
    "\x03\x02\x02\x02[\\\x07\x0E\x02\x02\\]\x07\x0F\x02\x02]^\x07\x0E\x02\x02" +
    "^\x0F\x03\x02\x02\x02\f\x17\x1A <FIMRVY";
class EffectContext extends ParserRuleContext_1.ParserRuleContext {
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    // @Override
    get ruleIndex() { return EffectParser.RULE_effect; }
    copyFrom(ctx) {
        super.copyFrom(ctx);
    }
}
exports.EffectContext = EffectContext;
class ConcreteEffectContext extends EffectContext {
    concrete() {
        return this.getRuleContext(0, ConcreteContext);
    }
    constructor(ctx) {
        super(ctx.parent, ctx.invokingState);
        this.copyFrom(ctx);
    }
    // @Override
    enterRule(listener) {
        if (listener.enterConcreteEffect) {
            listener.enterConcreteEffect(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitConcreteEffect) {
            listener.exitConcreteEffect(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitConcreteEffect) {
            return visitor.visitConcreteEffect(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.ConcreteEffectContext = ConcreteEffectContext;
class ArrowEffectContext extends EffectContext {
    effect(i) {
        if (i === undefined) {
            return this.getRuleContexts(EffectContext);
        }
        else {
            return this.getRuleContext(i, EffectContext);
        }
    }
    constructor(ctx) {
        super(ctx.parent, ctx.invokingState);
        this.copyFrom(ctx);
    }
    // @Override
    enterRule(listener) {
        if (listener.enterArrowEffect) {
            listener.enterArrowEffect(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitArrowEffect) {
            listener.exitArrowEffect(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitArrowEffect) {
            return visitor.visitArrowEffect(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.ArrowEffectContext = ArrowEffectContext;
class VariableEffectContext extends EffectContext {
    IDENTIFIER() { return this.getToken(EffectParser.IDENTIFIER, 0); }
    constructor(ctx) {
        super(ctx.parent, ctx.invokingState);
        this.copyFrom(ctx);
    }
    // @Override
    enterRule(listener) {
        if (listener.enterVariableEffect) {
            listener.enterVariableEffect(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitVariableEffect) {
            listener.exitVariableEffect(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitVariableEffect) {
            return visitor.visitVariableEffect(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.VariableEffectContext = VariableEffectContext;
class ReadContext extends ParserRuleContext_1.ParserRuleContext {
    entity() {
        return this.getRuleContext(0, EntityContext);
    }
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    // @Override
    get ruleIndex() { return EffectParser.RULE_read; }
    // @Override
    enterRule(listener) {
        if (listener.enterRead) {
            listener.enterRead(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitRead) {
            listener.exitRead(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitRead) {
            return visitor.visitRead(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.ReadContext = ReadContext;
class UpdateContext extends ParserRuleContext_1.ParserRuleContext {
    entity() {
        return this.getRuleContext(0, EntityContext);
    }
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    // @Override
    get ruleIndex() { return EffectParser.RULE_update; }
    // @Override
    enterRule(listener) {
        if (listener.enterUpdate) {
            listener.enterUpdate(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitUpdate) {
            listener.exitUpdate(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitUpdate) {
            return visitor.visitUpdate(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.UpdateContext = UpdateContext;
class TemporalContext extends ParserRuleContext_1.ParserRuleContext {
    entity() {
        return this.getRuleContext(0, EntityContext);
    }
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    // @Override
    get ruleIndex() { return EffectParser.RULE_temporal; }
    // @Override
    enterRule(listener) {
        if (listener.enterTemporal) {
            listener.enterTemporal(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitTemporal) {
            listener.exitTemporal(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitTemporal) {
            return visitor.visitTemporal(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.TemporalContext = TemporalContext;
class ConcreteContext extends ParserRuleContext_1.ParserRuleContext {
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    // @Override
    get ruleIndex() { return EffectParser.RULE_concrete; }
    copyFrom(ctx) {
        super.copyFrom(ctx);
    }
}
exports.ConcreteContext = ConcreteContext;
class ReadOnlyContext extends ConcreteContext {
    read() {
        return this.getRuleContext(0, ReadContext);
    }
    constructor(ctx) {
        super(ctx.parent, ctx.invokingState);
        this.copyFrom(ctx);
    }
    // @Override
    enterRule(listener) {
        if (listener.enterReadOnly) {
            listener.enterReadOnly(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitReadOnly) {
            listener.exitReadOnly(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitReadOnly) {
            return visitor.visitReadOnly(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.ReadOnlyContext = ReadOnlyContext;
class UpdateOnlyContext extends ConcreteContext {
    update() {
        return this.getRuleContext(0, UpdateContext);
    }
    constructor(ctx) {
        super(ctx.parent, ctx.invokingState);
        this.copyFrom(ctx);
    }
    // @Override
    enterRule(listener) {
        if (listener.enterUpdateOnly) {
            listener.enterUpdateOnly(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitUpdateOnly) {
            listener.exitUpdateOnly(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitUpdateOnly) {
            return visitor.visitUpdateOnly(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.UpdateOnlyContext = UpdateOnlyContext;
class TemporalOnlyContext extends ConcreteContext {
    temporal() {
        return this.getRuleContext(0, TemporalContext);
    }
    constructor(ctx) {
        super(ctx.parent, ctx.invokingState);
        this.copyFrom(ctx);
    }
    // @Override
    enterRule(listener) {
        if (listener.enterTemporalOnly) {
            listener.enterTemporalOnly(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitTemporalOnly) {
            listener.exitTemporalOnly(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitTemporalOnly) {
            return visitor.visitTemporalOnly(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.TemporalOnlyContext = TemporalOnlyContext;
class ReadAndUpdateContext extends ConcreteContext {
    read() {
        return this.tryGetRuleContext(0, ReadContext);
    }
    update() {
        return this.tryGetRuleContext(0, UpdateContext);
    }
    constructor(ctx) {
        super(ctx.parent, ctx.invokingState);
        this.copyFrom(ctx);
    }
    // @Override
    enterRule(listener) {
        if (listener.enterReadAndUpdate) {
            listener.enterReadAndUpdate(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitReadAndUpdate) {
            listener.exitReadAndUpdate(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitReadAndUpdate) {
            return visitor.visitReadAndUpdate(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.ReadAndUpdateContext = ReadAndUpdateContext;
class ReadAndTemporalContext extends ConcreteContext {
    read() {
        return this.tryGetRuleContext(0, ReadContext);
    }
    temporal() {
        return this.tryGetRuleContext(0, TemporalContext);
    }
    update() {
        return this.tryGetRuleContext(0, UpdateContext);
    }
    constructor(ctx) {
        super(ctx.parent, ctx.invokingState);
        this.copyFrom(ctx);
    }
    // @Override
    enterRule(listener) {
        if (listener.enterReadAndTemporal) {
            listener.enterReadAndTemporal(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitReadAndTemporal) {
            listener.exitReadAndTemporal(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitReadAndTemporal) {
            return visitor.visitReadAndTemporal(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.ReadAndTemporalContext = ReadAndTemporalContext;
class PureContext extends ConcreteContext {
    constructor(ctx) {
        super(ctx.parent, ctx.invokingState);
        this.copyFrom(ctx);
    }
    // @Override
    enterRule(listener) {
        if (listener.enterPure) {
            listener.enterPure(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitPure) {
            listener.exitPure(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitPure) {
            return visitor.visitPure(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.PureContext = PureContext;
class EntityContext extends ParserRuleContext_1.ParserRuleContext {
    stateVarRef(i) {
        if (i === undefined) {
            return this.getRuleContexts(StateVarRefContext);
        }
        else {
            return this.getRuleContext(i, StateVarRefContext);
        }
    }
    IDENTIFIER(i) {
        if (i === undefined) {
            return this.getTokens(EffectParser.IDENTIFIER);
        }
        else {
            return this.getToken(EffectParser.IDENTIFIER, i);
        }
    }
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    // @Override
    get ruleIndex() { return EffectParser.RULE_entity; }
    // @Override
    enterRule(listener) {
        if (listener.enterEntity) {
            listener.enterEntity(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitEntity) {
            listener.exitEntity(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitEntity) {
            return visitor.visitEntity(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.EntityContext = EntityContext;
class StateVarRefContext extends ParserRuleContext_1.ParserRuleContext {
    IDENTIFIER() { return this.getToken(EffectParser.IDENTIFIER, 0); }
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    // @Override
    get ruleIndex() { return EffectParser.RULE_stateVarRef; }
    // @Override
    enterRule(listener) {
        if (listener.enterStateVarRef) {
            listener.enterStateVarRef(this);
        }
    }
    // @Override
    exitRule(listener) {
        if (listener.exitStateVarRef) {
            listener.exitStateVarRef(this);
        }
    }
    // @Override
    accept(visitor) {
        if (visitor.visitStateVarRef) {
            return visitor.visitStateVarRef(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.StateVarRefContext = StateVarRefContext;
//# sourceMappingURL=EffectParser.js.map