@malloydata/malloy-tag 0.0.237-dev250225144145

package/src/lib/Malloy/MalloyTagParser.ts

@@ -0,0 +1,1048 @@
+// Generated from MalloyTag.g4 by ANTLR 4.9.0-SNAPSHOT
+
+
+import { ATN } from "antlr4ts/atn/ATN";
+import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
+import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
+import { NotNull } from "antlr4ts/Decorators";
+import { NoViableAltException } from "antlr4ts/NoViableAltException";
+import { Override } from "antlr4ts/Decorators";
+import { Parser } from "antlr4ts/Parser";
+import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
+import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
+import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
+import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
+import { RecognitionException } from "antlr4ts/RecognitionException";
+import { RuleContext } from "antlr4ts/RuleContext";
+//import { RuleVersion } from "antlr4ts/RuleVersion";
+import { TerminalNode } from "antlr4ts/tree/TerminalNode";
+import { Token } from "antlr4ts/Token";
+import { TokenStream } from "antlr4ts/TokenStream";
+import { Vocabulary } from "antlr4ts/Vocabulary";
+import { VocabularyImpl } from "antlr4ts/VocabularyImpl";
+
+import * as Utils from "antlr4ts/misc/Utils";
+
+import { MalloyTagVisitor } from "./MalloyTagVisitor";
+
+
+export class MalloyTagParser extends Parser {
+	public static readonly MINUS_DOTTY = 1;
+	public static readonly DOTTY = 2;
+	public static readonly DOT = 3;
+	public static readonly MINUS = 4;
+	public static readonly EQ = 5;
+	public static readonly RF_BEG = 6;
+	public static readonly RF_END = 7;
+	public static readonly PR_BEG = 8;
+	public static readonly PR_END = 9;
+	public static readonly AR_BEG = 10;
+	public static readonly COMMA = 11;
+	public static readonly AR_END = 12;
+	public static readonly SQ_STRING = 13;
+	public static readonly DQ_STRING = 14;
+	public static readonly BQ_STRING = 15;
+	public static readonly NUMERIC_LITERAL = 16;
+	public static readonly BARE_STRING = 17;
+	public static readonly COMMENT = 18;
+	public static readonly WHITE_SPACE = 19;
+	public static readonly UNEXPECTED_CHAR = 20;
+	public static readonly RULE_tagLine = 0;
+	public static readonly RULE_tagSpec = 1;
+	public static readonly RULE_string = 2;
+	public static readonly RULE_identifier = 3;
+	public static readonly RULE_propName = 4;
+	public static readonly RULE_eqValue = 5;
+	public static readonly RULE_arrayElement = 6;
+	public static readonly RULE_reference = 7;
+	public static readonly RULE_arrayValue = 8;
+	public static readonly RULE_properties = 9;
+	// tslint:disable:no-trailing-whitespace
+	public static readonly ruleNames: string[] = [
+		"tagLine", "tagSpec", "string", "identifier", "propName", "eqValue", "arrayElement", 
+		"reference", "arrayValue", "properties",
+	];
+
+	private static readonly _LITERAL_NAMES: Array<string | undefined> = [
+		undefined, "'-...'", "'...'", "'.'", "'-'", "'='", "'$('", "')'", "'{'", 
+		"'}'", "'['", "','", "']'",
+	];
+	private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
+		undefined, "MINUS_DOTTY", "DOTTY", "DOT", "MINUS", "EQ", "RF_BEG", "RF_END", 
+		"PR_BEG", "PR_END", "AR_BEG", "COMMA", "AR_END", "SQ_STRING", "DQ_STRING", 
+		"BQ_STRING", "NUMERIC_LITERAL", "BARE_STRING", "COMMENT", "WHITE_SPACE", 
+		"UNEXPECTED_CHAR",
+	];
+	public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(MalloyTagParser._LITERAL_NAMES, MalloyTagParser._SYMBOLIC_NAMES, []);
+
+	// @Override
+	// @NotNull
+	public get vocabulary(): Vocabulary {
+		return MalloyTagParser.VOCABULARY;
+	}
+	// tslint:enable:no-trailing-whitespace
+
+	// @Override
+	public get grammarFileName(): string { return "MalloyTag.g4"; }
+
+	// @Override
+	public get ruleNames(): string[] { return MalloyTagParser.ruleNames; }
+
+	// @Override
+	public get serializedATN(): string { return MalloyTagParser._serializedATN; }
+
+	protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
+		return new FailedPredicateException(this, predicate, message);
+	}
+
+	constructor(input: TokenStream) {
+		super(input);
+		this._interp = new ParserATNSimulator(MalloyTagParser._ATN, this);
+	}
+	// @RuleVersion(0)
+	public tagLine(): TagLineContext {
+		let _localctx: TagLineContext = new TagLineContext(this._ctx, this.state);
+		this.enterRule(_localctx, 0, MalloyTagParser.RULE_tagLine);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 23;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << MalloyTagParser.MINUS_DOTTY) | (1 << MalloyTagParser.MINUS) | (1 << MalloyTagParser.BQ_STRING) | (1 << MalloyTagParser.BARE_STRING))) !== 0)) {
+				{
+				{
+				this.state = 20;
+				this.tagSpec();
+				}
+				}
+				this.state = 25;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			this.state = 26;
+			this.match(MalloyTagParser.EOF);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public tagSpec(): TagSpecContext {
+		let _localctx: TagSpecContext = new TagSpecContext(this._ctx, this.state);
+		this.enterRule(_localctx, 2, MalloyTagParser.RULE_tagSpec);
+		let _la: number;
+		try {
+			this.state = 49;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 4, this._ctx) ) {
+			case 1:
+				_localctx = new TagEqContext(_localctx);
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 28;
+				this.propName();
+				this.state = 29;
+				this.match(MalloyTagParser.EQ);
+				this.state = 30;
+				this.eqValue();
+				this.state = 32;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === MalloyTagParser.PR_BEG) {
+					{
+					this.state = 31;
+					this.properties();
+					}
+				}
+
+				}
+				break;
+
+			case 2:
+				_localctx = new TagReplacePropertiesContext(_localctx);
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 34;
+				this.propName();
+				this.state = 35;
+				this.match(MalloyTagParser.EQ);
+				this.state = 37;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === MalloyTagParser.DOTTY) {
+					{
+					this.state = 36;
+					this.match(MalloyTagParser.DOTTY);
+					}
+				}
+
+				this.state = 39;
+				this.properties();
+				}
+				break;
+
+			case 3:
+				_localctx = new TagUpdatePropertiesContext(_localctx);
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 41;
+				this.propName();
+				this.state = 42;
+				this.properties();
+				}
+				break;
+
+			case 4:
+				_localctx = new TagDefContext(_localctx);
+				this.enterOuterAlt(_localctx, 4);
+				{
+				this.state = 45;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === MalloyTagParser.MINUS) {
+					{
+					this.state = 44;
+					this.match(MalloyTagParser.MINUS);
+					}
+				}
+
+				this.state = 47;
+				this.propName();
+				}
+				break;
+
+			case 5:
+				_localctx = new TagEmptyContext(_localctx);
+				this.enterOuterAlt(_localctx, 5);
+				{
+				this.state = 48;
+				this.match(MalloyTagParser.MINUS_DOTTY);
+				}
+				break;
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public string(): StringContext {
+		let _localctx: StringContext = new StringContext(this._ctx, this.state);
+		this.enterRule(_localctx, 4, MalloyTagParser.RULE_string);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 51;
+			_la = this._input.LA(1);
+			if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << MalloyTagParser.SQ_STRING) | (1 << MalloyTagParser.DQ_STRING) | (1 << MalloyTagParser.NUMERIC_LITERAL) | (1 << MalloyTagParser.BARE_STRING))) !== 0))) {
+			this._errHandler.recoverInline(this);
+			} else {
+				if (this._input.LA(1) === Token.EOF) {
+					this.matchedEOF = true;
+				}
+
+				this._errHandler.reportMatch(this);
+				this.consume();
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public identifier(): IdentifierContext {
+		let _localctx: IdentifierContext = new IdentifierContext(this._ctx, this.state);
+		this.enterRule(_localctx, 6, MalloyTagParser.RULE_identifier);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 53;
+			_la = this._input.LA(1);
+			if (!(_la === MalloyTagParser.BQ_STRING || _la === MalloyTagParser.BARE_STRING)) {
+			this._errHandler.recoverInline(this);
+			} else {
+				if (this._input.LA(1) === Token.EOF) {
+					this.matchedEOF = true;
+				}
+
+				this._errHandler.reportMatch(this);
+				this.consume();
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public propName(): PropNameContext {
+		let _localctx: PropNameContext = new PropNameContext(this._ctx, this.state);
+		this.enterRule(_localctx, 8, MalloyTagParser.RULE_propName);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 55;
+			this.identifier();
+			this.state = 60;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while (_la === MalloyTagParser.DOT) {
+				{
+				{
+				this.state = 56;
+				this.match(MalloyTagParser.DOT);
+				this.state = 57;
+				this.identifier();
+				}
+				}
+				this.state = 62;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public eqValue(): EqValueContext {
+		let _localctx: EqValueContext = new EqValueContext(this._ctx, this.state);
+		this.enterRule(_localctx, 10, MalloyTagParser.RULE_eqValue);
+		try {
+			this.state = 66;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case MalloyTagParser.SQ_STRING:
+			case MalloyTagParser.DQ_STRING:
+			case MalloyTagParser.NUMERIC_LITERAL:
+			case MalloyTagParser.BARE_STRING:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 63;
+				this.string();
+				}
+				break;
+			case MalloyTagParser.AR_BEG:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 64;
+				this.arrayValue();
+				}
+				break;
+			case MalloyTagParser.RF_BEG:
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 65;
+				this.reference();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public arrayElement(): ArrayElementContext {
+		let _localctx: ArrayElementContext = new ArrayElementContext(this._ctx, this.state);
+		this.enterRule(_localctx, 12, MalloyTagParser.RULE_arrayElement);
+		let _la: number;
+		try {
+			this.state = 75;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case MalloyTagParser.SQ_STRING:
+			case MalloyTagParser.DQ_STRING:
+			case MalloyTagParser.NUMERIC_LITERAL:
+			case MalloyTagParser.BARE_STRING:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 68;
+				this.string();
+				this.state = 70;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === MalloyTagParser.PR_BEG) {
+					{
+					this.state = 69;
+					this.properties();
+					}
+				}
+
+				}
+				break;
+			case MalloyTagParser.PR_BEG:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 72;
+				this.properties();
+				}
+				break;
+			case MalloyTagParser.AR_BEG:
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 73;
+				this.arrayValue();
+				}
+				break;
+			case MalloyTagParser.RF_BEG:
+				this.enterOuterAlt(_localctx, 4);
+				{
+				this.state = 74;
+				this.reference();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public reference(): ReferenceContext {
+		let _localctx: ReferenceContext = new ReferenceContext(this._ctx, this.state);
+		this.enterRule(_localctx, 14, MalloyTagParser.RULE_reference);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 77;
+			this.match(MalloyTagParser.RF_BEG);
+			this.state = 78;
+			this.propName();
+			this.state = 79;
+			this.match(MalloyTagParser.RF_END);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public arrayValue(): ArrayValueContext {
+		let _localctx: ArrayValueContext = new ArrayValueContext(this._ctx, this.state);
+		this.enterRule(_localctx, 16, MalloyTagParser.RULE_arrayValue);
+		let _la: number;
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 81;
+			this.match(MalloyTagParser.AR_BEG);
+			this.state = 82;
+			this.arrayElement();
+			this.state = 87;
+			this._errHandler.sync(this);
+			_alt = this.interpreter.adaptivePredict(this._input, 9, this._ctx);
+			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+				if (_alt === 1) {
+					{
+					{
+					this.state = 83;
+					this.match(MalloyTagParser.COMMA);
+					this.state = 84;
+					this.arrayElement();
+					}
+					}
+				}
+				this.state = 89;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 9, this._ctx);
+			}
+			this.state = 91;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === MalloyTagParser.COMMA) {
+				{
+				this.state = 90;
+				this.match(MalloyTagParser.COMMA);
+				}
+			}
+
+			this.state = 93;
+			this.match(MalloyTagParser.AR_END);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public properties(): PropertiesContext {
+		let _localctx: PropertiesContext = new PropertiesContext(this._ctx, this.state);
+		this.enterRule(_localctx, 18, MalloyTagParser.RULE_properties);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 95;
+			this.match(MalloyTagParser.PR_BEG);
+			this.state = 103;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case MalloyTagParser.DOTTY:
+				{
+				this.state = 96;
+				this.match(MalloyTagParser.DOTTY);
+				}
+				break;
+			case MalloyTagParser.MINUS_DOTTY:
+			case MalloyTagParser.MINUS:
+			case MalloyTagParser.PR_END:
+			case MalloyTagParser.BQ_STRING:
+			case MalloyTagParser.BARE_STRING:
+				{
+				{
+				this.state = 100;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << MalloyTagParser.MINUS_DOTTY) | (1 << MalloyTagParser.MINUS) | (1 << MalloyTagParser.BQ_STRING) | (1 << MalloyTagParser.BARE_STRING))) !== 0)) {
+					{
+					{
+					this.state = 97;
+					this.tagSpec();
+					}
+					}
+					this.state = 102;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+				}
+				}
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			this.state = 105;
+			this.match(MalloyTagParser.PR_END);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+
+	public static readonly _serializedATN: string =
+		"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x16n\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\x04\t\t\t\x04\n\t\n\x04\v\t\v\x03\x02\x07\x02\x18\n\x02" +
+		"\f\x02\x0E\x02\x1B\v\x02\x03\x02\x03\x02\x03\x03\x03\x03\x03\x03\x03\x03" +
+		"\x05\x03#\n\x03\x03\x03\x03\x03\x03\x03\x05\x03(\n\x03\x03\x03\x03\x03" +
+		"\x03\x03\x03\x03\x03\x03\x03\x03\x05\x030\n\x03\x03\x03\x03\x03\x05\x03" +
+		"4\n\x03\x03\x04\x03\x04\x03\x05\x03\x05\x03\x06\x03\x06\x03\x06\x07\x06" +
+		"=\n\x06\f\x06\x0E\x06@\v\x06\x03\x07\x03\x07\x03\x07\x05\x07E\n\x07\x03" +
+		"\b\x03\b\x05\bI\n\b\x03\b\x03\b\x03\b\x05\bN\n\b\x03\t\x03\t\x03\t\x03" +
+		"\t\x03\n\x03\n\x03\n\x03\n\x07\nX\n\n\f\n\x0E\n[\v\n\x03\n\x05\n^\n\n" +
+		"\x03\n\x03\n\x03\v\x03\v\x03\v\x07\ve\n\v\f\v\x0E\vh\v\v\x05\vj\n\v\x03" +
+		"\v\x03\v\x03\v\x02\x02\x02\f\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02" +
+		"\x0E\x02\x10\x02\x12\x02\x14\x02\x02\x04\x04\x02\x0F\x10\x12\x13\x04\x02" +
+		"\x11\x11\x13\x13\x02v\x02\x19\x03\x02\x02\x02\x043\x03\x02\x02\x02\x06" +
+		"5\x03\x02\x02\x02\b7\x03\x02\x02\x02\n9\x03\x02\x02\x02\fD\x03\x02\x02" +
+		"\x02\x0EM\x03\x02\x02\x02\x10O\x03\x02\x02\x02\x12S\x03\x02\x02\x02\x14" +
+		"a\x03\x02\x02\x02\x16\x18\x05\x04\x03\x02\x17\x16\x03\x02\x02\x02\x18" +
+		"\x1B\x03\x02\x02\x02\x19\x17\x03\x02\x02\x02\x19\x1A\x03\x02\x02\x02\x1A" +
+		"\x1C\x03\x02\x02\x02\x1B\x19\x03\x02\x02\x02\x1C\x1D\x07\x02\x02\x03\x1D" +
+		"\x03\x03\x02\x02\x02\x1E\x1F\x05\n\x06\x02\x1F \x07\x07\x02\x02 \"\x05" +
+		"\f\x07\x02!#\x05\x14\v\x02\"!\x03\x02\x02\x02\"#\x03\x02\x02\x02#4\x03" +
+		"\x02\x02\x02$%\x05\n\x06\x02%\'\x07\x07\x02\x02&(\x07\x04\x02\x02\'&\x03" +
+		"\x02\x02\x02\'(\x03\x02\x02\x02()\x03\x02\x02\x02)*\x05\x14\v\x02*4\x03" +
+		"\x02\x02\x02+,\x05\n\x06\x02,-\x05\x14\v\x02-4\x03\x02\x02\x02.0\x07\x06" +
+		"\x02\x02/.\x03\x02\x02\x02/0\x03\x02\x02\x0201\x03\x02\x02\x0214\x05\n" +
+		"\x06\x0224\x07\x03\x02\x023\x1E\x03\x02\x02\x023$\x03\x02\x02\x023+\x03" +
+		"\x02\x02\x023/\x03\x02\x02\x0232\x03\x02\x02\x024\x05\x03\x02\x02\x02" +
+		"56\t\x02\x02\x026\x07\x03\x02\x02\x0278\t\x03\x02\x028\t\x03\x02\x02\x02" +
+		"9>\x05\b\x05\x02:;\x07\x05\x02\x02;=\x05\b\x05\x02<:\x03\x02\x02\x02=" +
+		"@\x03\x02\x02\x02><\x03\x02\x02\x02>?\x03\x02\x02\x02?\v\x03\x02\x02\x02" +
+		"@>\x03\x02\x02\x02AE\x05\x06\x04\x02BE\x05\x12\n\x02CE\x05\x10\t\x02D" +
+		"A\x03\x02\x02\x02DB\x03\x02\x02\x02DC\x03\x02\x02\x02E\r\x03\x02\x02\x02" +
+		"FH\x05\x06\x04\x02GI\x05\x14\v\x02HG\x03\x02\x02\x02HI\x03\x02\x02\x02" +
+		"IN\x03\x02\x02\x02JN\x05\x14\v\x02KN\x05\x12\n\x02LN\x05\x10\t\x02MF\x03" +
+		"\x02\x02\x02MJ\x03\x02\x02\x02MK\x03\x02\x02\x02ML\x03\x02\x02\x02N\x0F" +
+		"\x03\x02\x02\x02OP\x07\b\x02\x02PQ\x05\n\x06\x02QR\x07\t\x02\x02R\x11" +
+		"\x03\x02\x02\x02ST\x07\f\x02\x02TY\x05\x0E\b\x02UV\x07\r\x02\x02VX\x05" +
+		"\x0E\b\x02WU\x03\x02\x02\x02X[\x03\x02\x02\x02YW\x03\x02\x02\x02YZ\x03" +
+		"\x02\x02\x02Z]\x03\x02\x02\x02[Y\x03\x02\x02\x02\\^\x07\r\x02\x02]\\\x03" +
+		"\x02\x02\x02]^\x03\x02\x02\x02^_\x03\x02\x02\x02_`\x07\x0E\x02\x02`\x13" +
+		"\x03\x02\x02\x02ai\x07\n\x02\x02bj\x07\x04\x02\x02ce\x05\x04\x03\x02d" +
+		"c\x03\x02\x02\x02eh\x03\x02\x02\x02fd\x03\x02\x02\x02fg\x03\x02\x02\x02" +
+		"gj\x03\x02\x02\x02hf\x03\x02\x02\x02ib\x03\x02\x02\x02if\x03\x02\x02\x02" +
+		"jk\x03\x02\x02\x02kl\x07\v\x02\x02l\x15\x03\x02\x02\x02\x0F\x19\"\'/3" +
+		">DHMY]fi";
+	public static __ATN: ATN;
+	public static get _ATN(): ATN {
+		if (!MalloyTagParser.__ATN) {
+			MalloyTagParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(MalloyTagParser._serializedATN));
+		}
+
+		return MalloyTagParser.__ATN;
+	}
+
+}
+
+export class TagLineContext extends ParserRuleContext {
+	public EOF(): TerminalNode { return this.getToken(MalloyTagParser.EOF, 0); }
+	public tagSpec(): TagSpecContext[];
+	public tagSpec(i: number): TagSpecContext;
+	public tagSpec(i?: number): TagSpecContext | TagSpecContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(TagSpecContext);
+		} else {
+			return this.getRuleContext(i, TagSpecContext);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return MalloyTagParser.RULE_tagLine; }
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitTagLine) {
+			return visitor.visitTagLine(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TagSpecContext extends ParserRuleContext {
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return MalloyTagParser.RULE_tagSpec; }
+	public copyFrom(ctx: TagSpecContext): void {
+		super.copyFrom(ctx);
+	}
+}
+export class TagEqContext extends TagSpecContext {
+	public propName(): PropNameContext {
+		return this.getRuleContext(0, PropNameContext);
+	}
+	public EQ(): TerminalNode { return this.getToken(MalloyTagParser.EQ, 0); }
+	public eqValue(): EqValueContext {
+		return this.getRuleContext(0, EqValueContext);
+	}
+	public properties(): PropertiesContext | undefined {
+		return this.tryGetRuleContext(0, PropertiesContext);
+	}
+	constructor(ctx: TagSpecContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitTagEq) {
+			return visitor.visitTagEq(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class TagReplacePropertiesContext extends TagSpecContext {
+	public propName(): PropNameContext {
+		return this.getRuleContext(0, PropNameContext);
+	}
+	public EQ(): TerminalNode { return this.getToken(MalloyTagParser.EQ, 0); }
+	public properties(): PropertiesContext {
+		return this.getRuleContext(0, PropertiesContext);
+	}
+	public DOTTY(): TerminalNode | undefined { return this.tryGetToken(MalloyTagParser.DOTTY, 0); }
+	constructor(ctx: TagSpecContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitTagReplaceProperties) {
+			return visitor.visitTagReplaceProperties(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class TagUpdatePropertiesContext extends TagSpecContext {
+	public propName(): PropNameContext {
+		return this.getRuleContext(0, PropNameContext);
+	}
+	public properties(): PropertiesContext {
+		return this.getRuleContext(0, PropertiesContext);
+	}
+	constructor(ctx: TagSpecContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitTagUpdateProperties) {
+			return visitor.visitTagUpdateProperties(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class TagDefContext extends TagSpecContext {
+	public propName(): PropNameContext {
+		return this.getRuleContext(0, PropNameContext);
+	}
+	public MINUS(): TerminalNode | undefined { return this.tryGetToken(MalloyTagParser.MINUS, 0); }
+	constructor(ctx: TagSpecContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitTagDef) {
+			return visitor.visitTagDef(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class TagEmptyContext extends TagSpecContext {
+	public MINUS_DOTTY(): TerminalNode { return this.getToken(MalloyTagParser.MINUS_DOTTY, 0); }
+	constructor(ctx: TagSpecContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitTagEmpty) {
+			return visitor.visitTagEmpty(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class StringContext extends ParserRuleContext {
+	public SQ_STRING(): TerminalNode | undefined { return this.tryGetToken(MalloyTagParser.SQ_STRING, 0); }
+	public DQ_STRING(): TerminalNode | undefined { return this.tryGetToken(MalloyTagParser.DQ_STRING, 0); }
+	public BARE_STRING(): TerminalNode | undefined { return this.tryGetToken(MalloyTagParser.BARE_STRING, 0); }
+	public NUMERIC_LITERAL(): TerminalNode | undefined { return this.tryGetToken(MalloyTagParser.NUMERIC_LITERAL, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return MalloyTagParser.RULE_string; }
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitString) {
+			return visitor.visitString(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class IdentifierContext extends ParserRuleContext {
+	public BQ_STRING(): TerminalNode | undefined { return this.tryGetToken(MalloyTagParser.BQ_STRING, 0); }
+	public BARE_STRING(): TerminalNode | undefined { return this.tryGetToken(MalloyTagParser.BARE_STRING, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return MalloyTagParser.RULE_identifier; }
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitIdentifier) {
+			return visitor.visitIdentifier(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class PropNameContext extends ParserRuleContext {
+	public identifier(): IdentifierContext[];
+	public identifier(i: number): IdentifierContext;
+	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(IdentifierContext);
+		} else {
+			return this.getRuleContext(i, IdentifierContext);
+		}
+	}
+	public DOT(): TerminalNode[];
+	public DOT(i: number): TerminalNode;
+	public DOT(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(MalloyTagParser.DOT);
+		} else {
+			return this.getToken(MalloyTagParser.DOT, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return MalloyTagParser.RULE_propName; }
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitPropName) {
+			return visitor.visitPropName(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class EqValueContext extends ParserRuleContext {
+	public string(): StringContext | undefined {
+		return this.tryGetRuleContext(0, StringContext);
+	}
+	public arrayValue(): ArrayValueContext | undefined {
+		return this.tryGetRuleContext(0, ArrayValueContext);
+	}
+	public reference(): ReferenceContext | undefined {
+		return this.tryGetRuleContext(0, ReferenceContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return MalloyTagParser.RULE_eqValue; }
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitEqValue) {
+			return visitor.visitEqValue(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ArrayElementContext extends ParserRuleContext {
+	public string(): StringContext | undefined {
+		return this.tryGetRuleContext(0, StringContext);
+	}
+	public properties(): PropertiesContext | undefined {
+		return this.tryGetRuleContext(0, PropertiesContext);
+	}
+	public arrayValue(): ArrayValueContext | undefined {
+		return this.tryGetRuleContext(0, ArrayValueContext);
+	}
+	public reference(): ReferenceContext | undefined {
+		return this.tryGetRuleContext(0, ReferenceContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return MalloyTagParser.RULE_arrayElement; }
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitArrayElement) {
+			return visitor.visitArrayElement(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ReferenceContext extends ParserRuleContext {
+	public RF_BEG(): TerminalNode { return this.getToken(MalloyTagParser.RF_BEG, 0); }
+	public propName(): PropNameContext {
+		return this.getRuleContext(0, PropNameContext);
+	}
+	public RF_END(): TerminalNode { return this.getToken(MalloyTagParser.RF_END, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return MalloyTagParser.RULE_reference; }
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitReference) {
+			return visitor.visitReference(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ArrayValueContext extends ParserRuleContext {
+	public AR_BEG(): TerminalNode { return this.getToken(MalloyTagParser.AR_BEG, 0); }
+	public arrayElement(): ArrayElementContext[];
+	public arrayElement(i: number): ArrayElementContext;
+	public arrayElement(i?: number): ArrayElementContext | ArrayElementContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ArrayElementContext);
+		} else {
+			return this.getRuleContext(i, ArrayElementContext);
+		}
+	}
+	public AR_END(): TerminalNode { return this.getToken(MalloyTagParser.AR_END, 0); }
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(MalloyTagParser.COMMA);
+		} else {
+			return this.getToken(MalloyTagParser.COMMA, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return MalloyTagParser.RULE_arrayValue; }
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitArrayValue) {
+			return visitor.visitArrayValue(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class PropertiesContext extends ParserRuleContext {
+	public PR_BEG(): TerminalNode { return this.getToken(MalloyTagParser.PR_BEG, 0); }
+	public PR_END(): TerminalNode { return this.getToken(MalloyTagParser.PR_END, 0); }
+	public DOTTY(): TerminalNode | undefined { return this.tryGetToken(MalloyTagParser.DOTTY, 0); }
+	public tagSpec(): TagSpecContext[];
+	public tagSpec(i: number): TagSpecContext;
+	public tagSpec(i?: number): TagSpecContext | TagSpecContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(TagSpecContext);
+		} else {
+			return this.getRuleContext(i, TagSpecContext);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return MalloyTagParser.RULE_properties; }
+	// @Override
+	public accept<Result>(visitor: MalloyTagVisitor<Result>): Result {
+		if (visitor.visitProperties) {
+			return visitor.visitProperties(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+