brett-compiler 1.0.2 → 1.0.18

package/dist/generated/BrettParser.js

@@ -0,0 +1,3990 @@
+// Generated from /builds/kdg-ti/programmeren-3/projecten-25-26/brett.deswert/Compiler/src/g4/Brett.g4 by ANTLR 4.13.2
+// jshint ignore: start
+import antlr4 from 'antlr4';
+import BrettListener from './BrettListener.js';
+import BrettVisitor from './BrettVisitor.js';
+
+const serializedATN = [4,1,57,342,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,
+4,2,5,7,5,2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,
+2,13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
+20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,1,0,
+5,0,56,8,0,10,0,12,0,59,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,3,1,76,8,1,1,2,1,2,5,2,80,8,2,10,2,12,2,83,9,2,1,2,1,2,1,
+3,1,3,1,3,1,3,3,3,91,8,3,1,3,1,3,3,3,95,8,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,
+1,3,1,3,1,3,3,3,107,8,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,116,8,4,1,5,1,5,
+1,5,1,5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,3,7,136,
+8,7,1,7,3,7,139,8,7,1,7,1,7,3,7,143,8,7,1,7,1,7,1,7,1,8,1,8,1,8,4,8,151,
+8,8,11,8,12,8,152,1,8,3,8,156,8,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,10,1,10,
+1,10,1,10,1,11,1,11,3,11,171,8,11,1,11,1,11,1,12,1,12,1,12,1,13,1,13,1,13,
+1,14,1,14,1,14,1,15,1,15,1,15,1,15,3,15,188,8,15,1,15,1,15,1,15,3,15,193,
+8,15,1,15,1,15,1,16,1,16,1,16,5,16,200,8,16,10,16,12,16,203,9,16,1,17,1,
+17,1,17,3,17,208,8,17,1,18,1,18,1,18,1,18,1,18,5,18,215,8,18,10,18,12,18,
+218,9,18,1,19,1,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,3,20,229,8,20,1,20,
+1,20,1,20,1,20,3,20,235,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,
+3,21,246,8,21,1,21,1,21,1,21,3,21,251,8,21,1,21,1,21,1,21,1,21,1,21,1,21,
+1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,
+21,1,21,5,21,275,8,21,10,21,12,21,278,9,21,1,22,1,22,1,22,1,22,1,22,1,22,
+1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,293,8,22,1,22,1,22,1,22,3,22,298,
+8,22,1,23,1,23,1,23,1,23,5,23,304,8,23,10,23,12,23,307,9,23,3,23,309,8,23,
+1,23,1,23,1,24,1,24,1,24,1,24,5,24,317,8,24,10,24,12,24,320,9,24,3,24,322,
+8,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25,3,25,332,8,25,1,26,1,26,1,26,
+5,26,337,8,26,10,26,12,26,340,9,26,1,26,0,2,36,42,27,0,2,4,6,8,10,12,14,
+16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,0,6,3,0,2,5,25,
+25,54,54,1,0,6,7,1,0,40,41,1,0,38,39,1,0,34,37,1,0,32,33,373,0,57,1,0,0,
+0,2,75,1,0,0,0,4,77,1,0,0,0,6,106,1,0,0,0,8,108,1,0,0,0,10,117,1,0,0,0,12,
+123,1,0,0,0,14,131,1,0,0,0,16,147,1,0,0,0,18,159,1,0,0,0,20,164,1,0,0,0,
+22,168,1,0,0,0,24,174,1,0,0,0,26,177,1,0,0,0,28,180,1,0,0,0,30,183,1,0,0,
+0,32,196,1,0,0,0,34,204,1,0,0,0,36,209,1,0,0,0,38,219,1,0,0,0,40,221,1,0,
+0,0,42,250,1,0,0,0,44,297,1,0,0,0,46,299,1,0,0,0,48,312,1,0,0,0,50,331,1,
+0,0,0,52,333,1,0,0,0,54,56,3,2,1,0,55,54,1,0,0,0,56,59,1,0,0,0,57,55,1,0,
+0,0,57,58,1,0,0,0,58,60,1,0,0,0,59,57,1,0,0,0,60,61,5,0,0,1,61,1,1,0,0,0,
+62,76,3,6,3,0,63,76,3,30,15,0,64,76,3,8,4,0,65,76,3,10,5,0,66,76,3,14,7,
+0,67,76,3,16,8,0,68,76,3,22,11,0,69,76,3,28,14,0,70,76,3,4,2,0,71,76,3,24,
+12,0,72,76,3,26,13,0,73,76,3,12,6,0,74,76,3,40,20,0,75,62,1,0,0,0,75,63,
+1,0,0,0,75,64,1,0,0,0,75,65,1,0,0,0,75,66,1,0,0,0,75,67,1,0,0,0,75,68,1,
+0,0,0,75,69,1,0,0,0,75,70,1,0,0,0,75,71,1,0,0,0,75,72,1,0,0,0,75,73,1,0,
+0,0,75,74,1,0,0,0,76,3,1,0,0,0,77,81,5,49,0,0,78,80,3,2,1,0,79,78,1,0,0,
+0,80,83,1,0,0,0,81,79,1,0,0,0,81,82,1,0,0,0,82,84,1,0,0,0,83,81,1,0,0,0,
+84,85,5,50,0,0,85,5,1,0,0,0,86,87,5,11,0,0,87,90,5,54,0,0,88,89,5,44,0,0,
+89,91,3,36,18,0,90,88,1,0,0,0,90,91,1,0,0,0,91,94,1,0,0,0,92,93,5,42,0,0,
+93,95,3,42,21,0,94,92,1,0,0,0,94,95,1,0,0,0,95,96,1,0,0,0,96,107,5,43,0,
+0,97,98,5,12,0,0,98,99,5,54,0,0,99,100,5,44,0,0,100,101,3,36,18,0,101,102,
+1,0,0,0,102,103,5,42,0,0,103,104,3,42,21,0,104,105,5,43,0,0,105,107,1,0,
+0,0,106,86,1,0,0,0,106,97,1,0,0,0,107,7,1,0,0,0,108,109,5,14,0,0,109,110,
+5,47,0,0,110,111,3,42,21,0,111,112,5,48,0,0,112,115,3,4,2,0,113,114,5,15,
+0,0,114,116,3,4,2,0,115,113,1,0,0,0,115,116,1,0,0,0,116,9,1,0,0,0,117,118,
+5,16,0,0,118,119,5,47,0,0,119,120,3,42,21,0,120,121,5,48,0,0,121,122,3,4,
+2,0,122,11,1,0,0,0,123,124,5,18,0,0,124,125,3,4,2,0,125,126,5,16,0,0,126,
+127,5,47,0,0,127,128,3,42,21,0,128,129,5,48,0,0,129,130,5,43,0,0,130,13,
+1,0,0,0,131,132,5,17,0,0,132,135,5,47,0,0,133,136,3,6,3,0,134,136,3,28,14,
+0,135,133,1,0,0,0,135,134,1,0,0,0,135,136,1,0,0,0,136,138,1,0,0,0,137,139,
+3,42,21,0,138,137,1,0,0,0,138,139,1,0,0,0,139,140,1,0,0,0,140,142,5,43,0,
+0,141,143,3,42,21,0,142,141,1,0,0,0,142,143,1,0,0,0,143,144,1,0,0,0,144,
+145,5,48,0,0,145,146,3,4,2,0,146,15,1,0,0,0,147,148,5,26,0,0,148,150,5,49,
+0,0,149,151,3,18,9,0,150,149,1,0,0,0,151,152,1,0,0,0,152,150,1,0,0,0,152,
+153,1,0,0,0,153,155,1,0,0,0,154,156,3,20,10,0,155,154,1,0,0,0,155,156,1,
+0,0,0,156,157,1,0,0,0,157,158,5,50,0,0,158,17,1,0,0,0,159,160,5,27,0,0,160,
+161,3,42,21,0,161,162,5,53,0,0,162,163,3,4,2,0,163,19,1,0,0,0,164,165,5,
+28,0,0,165,166,5,53,0,0,166,167,3,4,2,0,167,21,1,0,0,0,168,170,5,29,0,0,
+169,171,3,42,21,0,170,169,1,0,0,0,170,171,1,0,0,0,171,172,1,0,0,0,172,173,
+5,43,0,0,173,23,1,0,0,0,174,175,5,22,0,0,175,176,5,43,0,0,176,25,1,0,0,0,
+177,178,5,23,0,0,178,179,5,43,0,0,179,27,1,0,0,0,180,181,3,42,21,0,181,182,
+5,43,0,0,182,29,1,0,0,0,183,184,5,13,0,0,184,185,5,54,0,0,185,187,5,47,0,
+0,186,188,3,32,16,0,187,186,1,0,0,0,187,188,1,0,0,0,188,189,1,0,0,0,189,
+192,5,48,0,0,190,191,5,44,0,0,191,193,3,36,18,0,192,190,1,0,0,0,192,193,
+1,0,0,0,193,194,1,0,0,0,194,195,3,4,2,0,195,31,1,0,0,0,196,201,3,34,17,0,
+197,198,5,45,0,0,198,200,3,34,17,0,199,197,1,0,0,0,200,203,1,0,0,0,201,199,
+1,0,0,0,201,202,1,0,0,0,202,33,1,0,0,0,203,201,1,0,0,0,204,207,5,54,0,0,
+205,206,5,44,0,0,206,208,3,36,18,0,207,205,1,0,0,0,207,208,1,0,0,0,208,35,
+1,0,0,0,209,210,6,18,-1,0,210,211,3,38,19,0,211,216,1,0,0,0,212,213,10,1,
+0,0,213,215,5,1,0,0,214,212,1,0,0,0,215,218,1,0,0,0,216,214,1,0,0,0,216,
+217,1,0,0,0,217,37,1,0,0,0,218,216,1,0,0,0,219,220,7,0,0,0,220,39,1,0,0,
+0,221,222,5,19,0,0,222,223,3,4,2,0,223,224,5,20,0,0,224,225,5,47,0,0,225,
+228,5,54,0,0,226,227,5,44,0,0,227,229,3,36,18,0,228,226,1,0,0,0,228,229,
+1,0,0,0,229,230,1,0,0,0,230,231,5,48,0,0,231,234,3,4,2,0,232,233,5,21,0,
+0,233,235,3,4,2,0,234,232,1,0,0,0,234,235,1,0,0,0,235,41,1,0,0,0,236,237,
+6,21,-1,0,237,251,3,44,22,0,238,239,5,54,0,0,239,240,5,42,0,0,240,251,3,
+42,21,6,241,242,5,24,0,0,242,243,5,54,0,0,243,245,5,47,0,0,244,246,3,52,
+26,0,245,244,1,0,0,0,245,246,1,0,0,0,246,247,1,0,0,0,247,251,5,48,0,0,248,
+249,7,1,0,0,249,251,3,42,21,1,250,236,1,0,0,0,250,238,1,0,0,0,250,241,1,
+0,0,0,250,248,1,0,0,0,251,276,1,0,0,0,252,253,10,10,0,0,253,254,7,2,0,0,
+254,275,3,42,21,11,255,256,10,9,0,0,256,257,7,3,0,0,257,275,3,42,21,10,258,
+259,10,8,0,0,259,260,7,4,0,0,260,275,3,42,21,9,261,262,10,7,0,0,262,263,
+7,5,0,0,263,275,3,42,21,8,264,265,10,5,0,0,265,266,5,51,0,0,266,267,3,42,
+21,0,267,268,5,52,0,0,268,275,1,0,0,0,269,270,10,4,0,0,270,271,5,46,0,0,
+271,275,5,54,0,0,272,273,10,2,0,0,273,275,7,1,0,0,274,252,1,0,0,0,274,255,
+1,0,0,0,274,258,1,0,0,0,274,261,1,0,0,0,274,264,1,0,0,0,274,269,1,0,0,0,
+274,272,1,0,0,0,275,278,1,0,0,0,276,274,1,0,0,0,276,277,1,0,0,0,277,43,1,
+0,0,0,278,276,1,0,0,0,279,298,5,30,0,0,280,298,5,31,0,0,281,298,5,8,0,0,
+282,298,5,9,0,0,283,298,5,10,0,0,284,298,5,54,0,0,285,286,5,47,0,0,286,287,
+3,42,21,0,287,288,5,48,0,0,288,298,1,0,0,0,289,290,5,54,0,0,290,292,5,47,
+0,0,291,293,3,52,26,0,292,291,1,0,0,0,292,293,1,0,0,0,293,294,1,0,0,0,294,
+298,5,48,0,0,295,298,3,46,23,0,296,298,3,48,24,0,297,279,1,0,0,0,297,280,
+1,0,0,0,297,281,1,0,0,0,297,282,1,0,0,0,297,283,1,0,0,0,297,284,1,0,0,0,
+297,285,1,0,0,0,297,289,1,0,0,0,297,295,1,0,0,0,297,296,1,0,0,0,298,45,1,
+0,0,0,299,308,5,51,0,0,300,305,3,42,21,0,301,302,5,45,0,0,302,304,3,42,21,
+0,303,301,1,0,0,0,304,307,1,0,0,0,305,303,1,0,0,0,305,306,1,0,0,0,306,309,
+1,0,0,0,307,305,1,0,0,0,308,300,1,0,0,0,308,309,1,0,0,0,309,310,1,0,0,0,
+310,311,5,52,0,0,311,47,1,0,0,0,312,321,5,49,0,0,313,318,3,50,25,0,314,315,
+5,45,0,0,315,317,3,50,25,0,316,314,1,0,0,0,317,320,1,0,0,0,318,316,1,0,0,
+0,318,319,1,0,0,0,319,322,1,0,0,0,320,318,1,0,0,0,321,313,1,0,0,0,321,322,
+1,0,0,0,322,323,1,0,0,0,323,324,5,50,0,0,324,49,1,0,0,0,325,326,5,54,0,0,
+326,327,5,44,0,0,327,332,3,42,21,0,328,329,5,31,0,0,329,330,5,44,0,0,330,
+332,3,42,21,0,331,325,1,0,0,0,331,328,1,0,0,0,332,51,1,0,0,0,333,338,3,42,
+21,0,334,335,5,45,0,0,335,337,3,42,21,0,336,334,1,0,0,0,337,340,1,0,0,0,
+338,336,1,0,0,0,338,339,1,0,0,0,339,53,1,0,0,0,340,338,1,0,0,0,32,57,75,
+81,90,94,106,115,135,138,142,152,155,170,187,192,201,207,216,228,234,245,
+250,274,276,292,297,305,308,318,321,331,338];
+
+
+const atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
+
+const decisionsToDFA = atn.decisionToState.map( (ds, index) => new antlr4.dfa.DFA(ds, index) );
+
+const sharedContextCache = new antlr4.atn.PredictionContextCache();
+
+export default class BrettParser extends antlr4.Parser {
+
+    static grammarFileName = "Brett.g4";
+    static literalNames = [ null, "'[]'", "'string'", "'number'", "'bool'", 
+                            "'any'", "'++'", "'--'", "'true'", "'false'", 
+                            "'nil'", "'let'", "'const'", "'def'", "'if'", 
+                            "'else'", "'while'", "'for'", "'do'", "'try'", 
+                            "'catch'", "'finally'", "'break'", "'continue'", 
+                            "'new'", "'void'", "'switch'", "'case'", "'default'", 
+                            "'return'", null, null, "'=='", "'!='", "'<='", 
+                            "'>='", "'<'", "'>'", "'+'", "'-'", "'*'", "'/'", 
+                            "'='", "';'", "':'", "','", "'.'", "'('", "')'", 
+                            "'{'", "'}'", "'['", "']'", "'=>'" ];
+    static symbolicNames = [ null, null, null, null, null, null, null, null, 
+                             null, null, null, "LET", "CONST", "DEF", "IF", 
+                             "ELSE", "WHILE", "FOR", "DO", "TRY", "CATCH", 
+                             "FINALLY", "BREAK", "CONTINUE", "NEW", "VOID", 
+                             "SWITCH", "CASE", "DEFAULT", "RETURN", "NUMBER", 
+                             "STRING", "EQ", "NEQ", "LE", "GE", "LT", "GT", 
+                             "PLUS", "MINUS", "STAR", "SLASH", "ASSIGN", 
+                             "SEMI", "COLON", "COMMA", "DOT", "LPAREN", 
+                             "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
+                             "ARROW", "IDENTIFIER", "WS", "LINE_COMMENT", 
+                             "BLOCK_COMMENT" ];
+    static ruleNames = [ "program", "statement", "block", "variableDeclaration", 
+                         "ifStatement", "whileStatement", "doWhileStatement", 
+                         "forStatement", "switchStatement", "switchCase", 
+                         "defaultCase", "returnStatement", "breakStatement", 
+                         "continueStatement", "expressionStatement", "functionDeclaration", 
+                         "parameterList", "parameter", "type", "baseType", 
+                         "tryCatchStatement", "expression", "primary", "arrayLiteral", 
+                         "objectLiteral", "property", "argList" ];
+
+    constructor(input) {
+        super(input);
+        this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
+        this.ruleNames = BrettParser.ruleNames;
+        this.literalNames = BrettParser.literalNames;
+        this.symbolicNames = BrettParser.symbolicNames;
+    }
+
+    sempred(localctx, ruleIndex, predIndex) {
+    	switch(ruleIndex) {
+    	case 18:
+    	    		return this.type_sempred(localctx, predIndex);
+    	case 21:
+    	    		return this.expression_sempred(localctx, predIndex);
+        default:
+            throw "No predicate with index:" + ruleIndex;
+       }
+    }
+
+    type_sempred(localctx, predIndex) {
+    	switch(predIndex) {
+    		case 0:
+    			return this.precpred(this._ctx, 1);
+    		default:
+    			throw "No predicate with index:" + predIndex;
+    	}
+    };
+
+    expression_sempred(localctx, predIndex) {
+    	switch(predIndex) {
+    		case 1:
+    			return this.precpred(this._ctx, 10);
+    		case 2:
+    			return this.precpred(this._ctx, 9);
+    		case 3:
+    			return this.precpred(this._ctx, 8);
+    		case 4:
+    			return this.precpred(this._ctx, 7);
+    		case 5:
+    			return this.precpred(this._ctx, 5);
+    		case 6:
+    			return this.precpred(this._ctx, 4);
+    		case 7:
+    			return this.precpred(this._ctx, 2);
+    		default:
+    			throw "No predicate with index:" + predIndex;
+    	}
+    };
+
+
+
+
+	program() {
+	    let localctx = new ProgramContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 0, BrettParser.RULE_program);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 57;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while((((_la) & ~0x1f) === 0 && ((1 << _la) & 3855581120) !== 0) || ((((_la - 47)) & ~0x1f) === 0 && ((1 << (_la - 47)) & 149) !== 0)) {
+	            this.state = 54;
+	            this.statement();
+	            this.state = 59;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 60;
+	        this.match(BrettParser.EOF);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	statement() {
+	    let localctx = new StatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 2, BrettParser.RULE_statement);
+	    try {
+	        this.state = 75;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,1,this._ctx);
+	        switch(la_) {
+	        case 1:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 62;
+	            this.variableDeclaration();
+	            break;
+
+	        case 2:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 63;
+	            this.functionDeclaration();
+	            break;
+
+	        case 3:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 64;
+	            this.ifStatement();
+	            break;
+
+	        case 4:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 65;
+	            this.whileStatement();
+	            break;
+
+	        case 5:
+	            this.enterOuterAlt(localctx, 5);
+	            this.state = 66;
+	            this.forStatement();
+	            break;
+
+	        case 6:
+	            this.enterOuterAlt(localctx, 6);
+	            this.state = 67;
+	            this.switchStatement();
+	            break;
+
+	        case 7:
+	            this.enterOuterAlt(localctx, 7);
+	            this.state = 68;
+	            this.returnStatement();
+	            break;
+
+	        case 8:
+	            this.enterOuterAlt(localctx, 8);
+	            this.state = 69;
+	            this.expressionStatement();
+	            break;
+
+	        case 9:
+	            this.enterOuterAlt(localctx, 9);
+	            this.state = 70;
+	            this.block();
+	            break;
+
+	        case 10:
+	            this.enterOuterAlt(localctx, 10);
+	            this.state = 71;
+	            this.breakStatement();
+	            break;
+
+	        case 11:
+	            this.enterOuterAlt(localctx, 11);
+	            this.state = 72;
+	            this.continueStatement();
+	            break;
+
+	        case 12:
+	            this.enterOuterAlt(localctx, 12);
+	            this.state = 73;
+	            this.doWhileStatement();
+	            break;
+
+	        case 13:
+	            this.enterOuterAlt(localctx, 13);
+	            this.state = 74;
+	            this.tryCatchStatement();
+	            break;
+
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	block() {
+	    let localctx = new BlockContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 4, BrettParser.RULE_block);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 77;
+	        this.match(BrettParser.LBRACE);
+	        this.state = 81;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while((((_la) & ~0x1f) === 0 && ((1 << _la) & 3855581120) !== 0) || ((((_la - 47)) & ~0x1f) === 0 && ((1 << (_la - 47)) & 149) !== 0)) {
+	            this.state = 78;
+	            this.statement();
+	            this.state = 83;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 84;
+	        this.match(BrettParser.RBRACE);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	variableDeclaration() {
+	    let localctx = new VariableDeclarationContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 6, BrettParser.RULE_variableDeclaration);
+	    var _la = 0;
+	    try {
+	        this.state = 106;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 11:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 86;
+	            this.match(BrettParser.LET);
+	            this.state = 87;
+	            this.match(BrettParser.IDENTIFIER);
+	            this.state = 90;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            if(_la===44) {
+	                this.state = 88;
+	                this.match(BrettParser.COLON);
+	                this.state = 89;
+	                this.type(0);
+	            }
+
+	            this.state = 94;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            if(_la===42) {
+	                this.state = 92;
+	                this.match(BrettParser.ASSIGN);
+	                this.state = 93;
+	                this.expression(0);
+	            }
+
+	            this.state = 96;
+	            this.match(BrettParser.SEMI);
+	            break;
+	        case 12:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 97;
+	            this.match(BrettParser.CONST);
+	            this.state = 98;
+	            this.match(BrettParser.IDENTIFIER);
+
+	            this.state = 99;
+	            this.match(BrettParser.COLON);
+	            this.state = 100;
+	            this.type(0);
+	            this.state = 102;
+	            this.match(BrettParser.ASSIGN);
+	            this.state = 103;
+	            this.expression(0);
+	            this.state = 104;
+	            this.match(BrettParser.SEMI);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	ifStatement() {
+	    let localctx = new IfStatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 8, BrettParser.RULE_ifStatement);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 108;
+	        this.match(BrettParser.IF);
+	        this.state = 109;
+	        this.match(BrettParser.LPAREN);
+	        this.state = 110;
+	        this.expression(0);
+	        this.state = 111;
+	        this.match(BrettParser.RPAREN);
+	        this.state = 112;
+	        this.block();
+	        this.state = 115;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===15) {
+	            this.state = 113;
+	            this.match(BrettParser.ELSE);
+	            this.state = 114;
+	            this.block();
+	        }
+
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	whileStatement() {
+	    let localctx = new WhileStatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 10, BrettParser.RULE_whileStatement);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 117;
+	        this.match(BrettParser.WHILE);
+	        this.state = 118;
+	        this.match(BrettParser.LPAREN);
+	        this.state = 119;
+	        this.expression(0);
+	        this.state = 120;
+	        this.match(BrettParser.RPAREN);
+	        this.state = 121;
+	        this.block();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	doWhileStatement() {
+	    let localctx = new DoWhileStatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 12, BrettParser.RULE_doWhileStatement);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 123;
+	        this.match(BrettParser.DO);
+	        this.state = 124;
+	        this.block();
+	        this.state = 125;
+	        this.match(BrettParser.WHILE);
+	        this.state = 126;
+	        this.match(BrettParser.LPAREN);
+	        this.state = 127;
+	        this.expression(0);
+	        this.state = 128;
+	        this.match(BrettParser.RPAREN);
+	        this.state = 129;
+	        this.match(BrettParser.SEMI);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	forStatement() {
+	    let localctx = new ForStatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 14, BrettParser.RULE_forStatement);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 131;
+	        this.match(BrettParser.FOR);
+	        this.state = 132;
+	        this.match(BrettParser.LPAREN);
+	        this.state = 135;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,7,this._ctx);
+	        if(la_===1) {
+	            this.state = 133;
+	            this.variableDeclaration();
+
+	        } else if(la_===2) {
+	            this.state = 134;
+	            this.expressionStatement();
+
+	        }
+	        this.state = 138;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 3238004672) !== 0) || ((((_la - 47)) & ~0x1f) === 0 && ((1 << (_la - 47)) & 149) !== 0)) {
+	            this.state = 137;
+	            this.expression(0);
+	        }
+
+	        this.state = 140;
+	        this.match(BrettParser.SEMI);
+	        this.state = 142;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 3238004672) !== 0) || ((((_la - 47)) & ~0x1f) === 0 && ((1 << (_la - 47)) & 149) !== 0)) {
+	            this.state = 141;
+	            this.expression(0);
+	        }
+
+	        this.state = 144;
+	        this.match(BrettParser.RPAREN);
+	        this.state = 145;
+	        this.block();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	switchStatement() {
+	    let localctx = new SwitchStatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 16, BrettParser.RULE_switchStatement);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 147;
+	        this.match(BrettParser.SWITCH);
+	        this.state = 148;
+	        this.match(BrettParser.LBRACE);
+	        this.state = 150; 
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        do {
+	            this.state = 149;
+	            this.switchCase();
+	            this.state = 152; 
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        } while(_la===27);
+	        this.state = 155;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===28) {
+	            this.state = 154;
+	            this.defaultCase();
+	        }
+
+	        this.state = 157;
+	        this.match(BrettParser.RBRACE);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	switchCase() {
+	    let localctx = new SwitchCaseContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 18, BrettParser.RULE_switchCase);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 159;
+	        this.match(BrettParser.CASE);
+	        this.state = 160;
+	        this.expression(0);
+	        this.state = 161;
+	        this.match(BrettParser.ARROW);
+	        this.state = 162;
+	        this.block();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	defaultCase() {
+	    let localctx = new DefaultCaseContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 20, BrettParser.RULE_defaultCase);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 164;
+	        this.match(BrettParser.DEFAULT);
+	        this.state = 165;
+	        this.match(BrettParser.ARROW);
+	        this.state = 166;
+	        this.block();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	returnStatement() {
+	    let localctx = new ReturnStatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 22, BrettParser.RULE_returnStatement);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 168;
+	        this.match(BrettParser.RETURN);
+	        this.state = 170;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 3238004672) !== 0) || ((((_la - 47)) & ~0x1f) === 0 && ((1 << (_la - 47)) & 149) !== 0)) {
+	            this.state = 169;
+	            this.expression(0);
+	        }
+
+	        this.state = 172;
+	        this.match(BrettParser.SEMI);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	breakStatement() {
+	    let localctx = new BreakStatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 24, BrettParser.RULE_breakStatement);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 174;
+	        this.match(BrettParser.BREAK);
+	        this.state = 175;
+	        this.match(BrettParser.SEMI);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	continueStatement() {
+	    let localctx = new ContinueStatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 26, BrettParser.RULE_continueStatement);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 177;
+	        this.match(BrettParser.CONTINUE);
+	        this.state = 178;
+	        this.match(BrettParser.SEMI);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	expressionStatement() {
+	    let localctx = new ExpressionStatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 28, BrettParser.RULE_expressionStatement);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 180;
+	        this.expression(0);
+	        this.state = 181;
+	        this.match(BrettParser.SEMI);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	functionDeclaration() {
+	    let localctx = new FunctionDeclarationContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 30, BrettParser.RULE_functionDeclaration);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 183;
+	        this.match(BrettParser.DEF);
+	        this.state = 184;
+	        this.match(BrettParser.IDENTIFIER);
+	        this.state = 185;
+	        this.match(BrettParser.LPAREN);
+	        this.state = 187;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===54) {
+	            this.state = 186;
+	            this.parameterList();
+	        }
+
+	        this.state = 189;
+	        this.match(BrettParser.RPAREN);
+	        this.state = 192;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===44) {
+	            this.state = 190;
+	            this.match(BrettParser.COLON);
+	            this.state = 191;
+	            this.type(0);
+	        }
+
+	        this.state = 194;
+	        this.block();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	parameterList() {
+	    let localctx = new ParameterListContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 32, BrettParser.RULE_parameterList);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 196;
+	        this.parameter();
+	        this.state = 201;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===45) {
+	            this.state = 197;
+	            this.match(BrettParser.COMMA);
+	            this.state = 198;
+	            this.parameter();
+	            this.state = 203;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	parameter() {
+	    let localctx = new ParameterContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 34, BrettParser.RULE_parameter);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 204;
+	        this.match(BrettParser.IDENTIFIER);
+	        this.state = 207;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===44) {
+	            this.state = 205;
+	            this.match(BrettParser.COLON);
+	            this.state = 206;
+	            this.type(0);
+	        }
+
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+	type(_p) {
+		if(_p===undefined) {
+		    _p = 0;
+		}
+	    const _parentctx = this._ctx;
+	    const _parentState = this.state;
+	    let localctx = new TypeContext(this, this._ctx, _parentState);
+	    let _prevctx = localctx;
+	    const _startState = 36;
+	    this.enterRecursionRule(localctx, 36, BrettParser.RULE_type, _p);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        localctx = new SimpleTypeContext(this, localctx);
+	        this._ctx = localctx;
+	        _prevctx = localctx;
+
+	        this.state = 210;
+	        this.baseType();
+	        this._ctx.stop = this._input.LT(-1);
+	        this.state = 216;
+	        this._errHandler.sync(this);
+	        var _alt = this._interp.adaptivePredict(this._input,17,this._ctx)
+	        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+	            if(_alt===1) {
+	                if(this._parseListeners!==null) {
+	                    this.triggerExitRuleEvent();
+	                }
+	                _prevctx = localctx;
+	                localctx = new ArrayTypeContext(this, new TypeContext(this, _parentctx, _parentState));
+	                this.pushNewRecursionContext(localctx, _startState, BrettParser.RULE_type);
+	                this.state = 212;
+	                if (!( this.precpred(this._ctx, 1))) {
+	                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
+	                }
+	                this.state = 213;
+	                this.match(BrettParser.T__0); 
+	            }
+	            this.state = 218;
+	            this._errHandler.sync(this);
+	            _alt = this._interp.adaptivePredict(this._input,17,this._ctx);
+	        }
+
+	    } catch( error) {
+	        if(error instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = error;
+		        this._errHandler.reportError(this, error);
+		        this._errHandler.recover(this, error);
+		    } else {
+		    	throw error;
+		    }
+	    } finally {
+	        this.unrollRecursionContexts(_parentctx)
+	    }
+	    return localctx;
+	}
+
+
+
+	baseType() {
+	    let localctx = new BaseTypeContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 38, BrettParser.RULE_baseType);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 219;
+	        _la = this._input.LA(1);
+	        if(!((((_la) & ~0x1f) === 0 && ((1 << _la) & 33554492) !== 0) || _la===54)) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	tryCatchStatement() {
+	    let localctx = new TryCatchStatementContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 40, BrettParser.RULE_tryCatchStatement);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 221;
+	        this.match(BrettParser.TRY);
+	        this.state = 222;
+	        this.block();
+	        this.state = 223;
+	        this.match(BrettParser.CATCH);
+	        this.state = 224;
+	        this.match(BrettParser.LPAREN);
+	        this.state = 225;
+	        this.match(BrettParser.IDENTIFIER);
+	        this.state = 228;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===44) {
+	            this.state = 226;
+	            this.match(BrettParser.COLON);
+	            this.state = 227;
+	            this.type(0);
+	        }
+
+	        this.state = 230;
+	        this.match(BrettParser.RPAREN);
+	        this.state = 231;
+	        this.block();
+	        this.state = 234;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===21) {
+	            this.state = 232;
+	            this.match(BrettParser.FINALLY);
+	            this.state = 233;
+	            this.block();
+	        }
+
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+	expression(_p) {
+		if(_p===undefined) {
+		    _p = 0;
+		}
+	    const _parentctx = this._ctx;
+	    const _parentState = this.state;
+	    let localctx = new ExpressionContext(this, this._ctx, _parentState);
+	    let _prevctx = localctx;
+	    const _startState = 42;
+	    this.enterRecursionRule(localctx, 42, BrettParser.RULE_expression, _p);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 250;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,21,this._ctx);
+	        switch(la_) {
+	        case 1:
+	            localctx = new PrimaryExpressionContext(this, localctx);
+	            this._ctx = localctx;
+	            _prevctx = localctx;
+
+	            this.state = 237;
+	            this.primary();
+	            break;
+
+	        case 2:
+	            localctx = new AssignmentExpressionContext(this, localctx);
+	            this._ctx = localctx;
+	            _prevctx = localctx;
+	            this.state = 238;
+	            this.match(BrettParser.IDENTIFIER);
+	            this.state = 239;
+	            this.match(BrettParser.ASSIGN);
+	            this.state = 240;
+	            this.expression(6);
+	            break;
+
+	        case 3:
+	            localctx = new NewExpressionContext(this, localctx);
+	            this._ctx = localctx;
+	            _prevctx = localctx;
+	            this.state = 241;
+	            this.match(BrettParser.NEW);
+	            this.state = 242;
+	            this.match(BrettParser.IDENTIFIER);
+	            this.state = 243;
+	            this.match(BrettParser.LPAREN);
+	            this.state = 245;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            if((((_la) & ~0x1f) === 0 && ((1 << _la) & 3238004672) !== 0) || ((((_la - 47)) & ~0x1f) === 0 && ((1 << (_la - 47)) & 149) !== 0)) {
+	                this.state = 244;
+	                this.argList();
+	            }
+
+	            this.state = 247;
+	            this.match(BrettParser.RPAREN);
+	            break;
+
+	        case 4:
+	            localctx = new PreIncrementDecrementContext(this, localctx);
+	            this._ctx = localctx;
+	            _prevctx = localctx;
+	            this.state = 248;
+	            _la = this._input.LA(1);
+	            if(!(_la===6 || _la===7)) {
+	            this._errHandler.recoverInline(this);
+	            }
+	            else {
+	            	this._errHandler.reportMatch(this);
+	                this.consume();
+	            }
+	            this.state = 249;
+	            this.expression(1);
+	            break;
+
+	        }
+	        this._ctx.stop = this._input.LT(-1);
+	        this.state = 276;
+	        this._errHandler.sync(this);
+	        var _alt = this._interp.adaptivePredict(this._input,23,this._ctx)
+	        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+	            if(_alt===1) {
+	                if(this._parseListeners!==null) {
+	                    this.triggerExitRuleEvent();
+	                }
+	                _prevctx = localctx;
+	                this.state = 274;
+	                this._errHandler.sync(this);
+	                var la_ = this._interp.adaptivePredict(this._input,22,this._ctx);
+	                switch(la_) {
+	                case 1:
+	                    localctx = new BinaryExpressionContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    this.pushNewRecursionContext(localctx, _startState, BrettParser.RULE_expression);
+	                    this.state = 252;
+	                    if (!( this.precpred(this._ctx, 10))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 10)");
+	                    }
+	                    this.state = 253;
+	                    localctx.op = this._input.LT(1);
+	                    _la = this._input.LA(1);
+	                    if(!(_la===40 || _la===41)) {
+	                        localctx.op = this._errHandler.recoverInline(this);
+	                    }
+	                    else {
+	                    	this._errHandler.reportMatch(this);
+	                        this.consume();
+	                    }
+	                    this.state = 254;
+	                    this.expression(11);
+	                    break;
+
+	                case 2:
+	                    localctx = new BinaryExpressionContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    this.pushNewRecursionContext(localctx, _startState, BrettParser.RULE_expression);
+	                    this.state = 255;
+	                    if (!( this.precpred(this._ctx, 9))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 9)");
+	                    }
+	                    this.state = 256;
+	                    localctx.op = this._input.LT(1);
+	                    _la = this._input.LA(1);
+	                    if(!(_la===38 || _la===39)) {
+	                        localctx.op = this._errHandler.recoverInline(this);
+	                    }
+	                    else {
+	                    	this._errHandler.reportMatch(this);
+	                        this.consume();
+	                    }
+	                    this.state = 257;
+	                    this.expression(10);
+	                    break;
+
+	                case 3:
+	                    localctx = new BinaryExpressionContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    this.pushNewRecursionContext(localctx, _startState, BrettParser.RULE_expression);
+	                    this.state = 258;
+	                    if (!( this.precpred(this._ctx, 8))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 8)");
+	                    }
+	                    this.state = 259;
+	                    localctx.op = this._input.LT(1);
+	                    _la = this._input.LA(1);
+	                    if(!(((((_la - 34)) & ~0x1f) === 0 && ((1 << (_la - 34)) & 15) !== 0))) {
+	                        localctx.op = this._errHandler.recoverInline(this);
+	                    }
+	                    else {
+	                    	this._errHandler.reportMatch(this);
+	                        this.consume();
+	                    }
+	                    this.state = 260;
+	                    this.expression(9);
+	                    break;
+
+	                case 4:
+	                    localctx = new BinaryExpressionContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    this.pushNewRecursionContext(localctx, _startState, BrettParser.RULE_expression);
+	                    this.state = 261;
+	                    if (!( this.precpred(this._ctx, 7))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 7)");
+	                    }
+	                    this.state = 262;
+	                    localctx.op = this._input.LT(1);
+	                    _la = this._input.LA(1);
+	                    if(!(_la===32 || _la===33)) {
+	                        localctx.op = this._errHandler.recoverInline(this);
+	                    }
+	                    else {
+	                    	this._errHandler.reportMatch(this);
+	                        this.consume();
+	                    }
+	                    this.state = 263;
+	                    this.expression(8);
+	                    break;
+
+	                case 5:
+	                    localctx = new IndexExpressionContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    this.pushNewRecursionContext(localctx, _startState, BrettParser.RULE_expression);
+	                    this.state = 264;
+	                    if (!( this.precpred(this._ctx, 5))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 5)");
+	                    }
+	                    this.state = 265;
+	                    this.match(BrettParser.LBRACK);
+	                    this.state = 266;
+	                    this.expression(0);
+	                    this.state = 267;
+	                    this.match(BrettParser.RBRACK);
+	                    break;
+
+	                case 6:
+	                    localctx = new MemberExpressionContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    this.pushNewRecursionContext(localctx, _startState, BrettParser.RULE_expression);
+	                    this.state = 269;
+	                    if (!( this.precpred(this._ctx, 4))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 4)");
+	                    }
+	                    this.state = 270;
+	                    this.match(BrettParser.DOT);
+	                    this.state = 271;
+	                    this.match(BrettParser.IDENTIFIER);
+	                    break;
+
+	                case 7:
+	                    localctx = new PostIncrementDecrementContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    this.pushNewRecursionContext(localctx, _startState, BrettParser.RULE_expression);
+	                    this.state = 272;
+	                    if (!( this.precpred(this._ctx, 2))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)");
+	                    }
+	                    this.state = 273;
+	                    _la = this._input.LA(1);
+	                    if(!(_la===6 || _la===7)) {
+	                    this._errHandler.recoverInline(this);
+	                    }
+	                    else {
+	                    	this._errHandler.reportMatch(this);
+	                        this.consume();
+	                    }
+	                    break;
+
+	                } 
+	            }
+	            this.state = 278;
+	            this._errHandler.sync(this);
+	            _alt = this._interp.adaptivePredict(this._input,23,this._ctx);
+	        }
+
+	    } catch( error) {
+	        if(error instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = error;
+		        this._errHandler.reportError(this, error);
+		        this._errHandler.recover(this, error);
+		    } else {
+		    	throw error;
+		    }
+	    } finally {
+	        this.unrollRecursionContexts(_parentctx)
+	    }
+	    return localctx;
+	}
+
+
+
+	primary() {
+	    let localctx = new PrimaryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 44, BrettParser.RULE_primary);
+	    var _la = 0;
+	    try {
+	        this.state = 297;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,25,this._ctx);
+	        switch(la_) {
+	        case 1:
+	            localctx = new LiteralExpressionContext(this, localctx);
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 279;
+	            this.match(BrettParser.NUMBER);
+	            break;
+
+	        case 2:
+	            localctx = new LiteralExpressionContext(this, localctx);
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 280;
+	            this.match(BrettParser.STRING);
+	            break;
+
+	        case 3:
+	            localctx = new LiteralExpressionContext(this, localctx);
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 281;
+	            this.match(BrettParser.T__7);
+	            break;
+
+	        case 4:
+	            localctx = new LiteralExpressionContext(this, localctx);
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 282;
+	            this.match(BrettParser.T__8);
+	            break;
+
+	        case 5:
+	            localctx = new LiteralExpressionContext(this, localctx);
+	            this.enterOuterAlt(localctx, 5);
+	            this.state = 283;
+	            this.match(BrettParser.T__9);
+	            break;
+
+	        case 6:
+	            localctx = new IdentifierExpressionContext(this, localctx);
+	            this.enterOuterAlt(localctx, 6);
+	            this.state = 284;
+	            this.match(BrettParser.IDENTIFIER);
+	            break;
+
+	        case 7:
+	            localctx = new ParenthesizedExpressionContext(this, localctx);
+	            this.enterOuterAlt(localctx, 7);
+	            this.state = 285;
+	            this.match(BrettParser.LPAREN);
+	            this.state = 286;
+	            this.expression(0);
+	            this.state = 287;
+	            this.match(BrettParser.RPAREN);
+	            break;
+
+	        case 8:
+	            localctx = new FunctionCallExpressionContext(this, localctx);
+	            this.enterOuterAlt(localctx, 8);
+	            this.state = 289;
+	            this.match(BrettParser.IDENTIFIER);
+	            this.state = 290;
+	            this.match(BrettParser.LPAREN);
+	            this.state = 292;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            if((((_la) & ~0x1f) === 0 && ((1 << _la) & 3238004672) !== 0) || ((((_la - 47)) & ~0x1f) === 0 && ((1 << (_la - 47)) & 149) !== 0)) {
+	                this.state = 291;
+	                this.argList();
+	            }
+
+	            this.state = 294;
+	            this.match(BrettParser.RPAREN);
+	            break;
+
+	        case 9:
+	            localctx = new ArrayLiteralExpressionContext(this, localctx);
+	            this.enterOuterAlt(localctx, 9);
+	            this.state = 295;
+	            this.arrayLiteral();
+	            break;
+
+	        case 10:
+	            localctx = new ObjectLiteralExpressionContext(this, localctx);
+	            this.enterOuterAlt(localctx, 10);
+	            this.state = 296;
+	            this.objectLiteral();
+	            break;
+
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	arrayLiteral() {
+	    let localctx = new ArrayLiteralContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 46, BrettParser.RULE_arrayLiteral);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 299;
+	        this.match(BrettParser.LBRACK);
+	        this.state = 308;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 3238004672) !== 0) || ((((_la - 47)) & ~0x1f) === 0 && ((1 << (_la - 47)) & 149) !== 0)) {
+	            this.state = 300;
+	            this.expression(0);
+	            this.state = 305;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            while(_la===45) {
+	                this.state = 301;
+	                this.match(BrettParser.COMMA);
+	                this.state = 302;
+	                this.expression(0);
+	                this.state = 307;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            }
+	        }
+
+	        this.state = 310;
+	        this.match(BrettParser.RBRACK);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	objectLiteral() {
+	    let localctx = new ObjectLiteralContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 48, BrettParser.RULE_objectLiteral);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 312;
+	        this.match(BrettParser.LBRACE);
+	        this.state = 321;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===31 || _la===54) {
+	            this.state = 313;
+	            this.property();
+	            this.state = 318;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            while(_la===45) {
+	                this.state = 314;
+	                this.match(BrettParser.COMMA);
+	                this.state = 315;
+	                this.property();
+	                this.state = 320;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            }
+	        }
+
+	        this.state = 323;
+	        this.match(BrettParser.RBRACE);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	property() {
+	    let localctx = new PropertyContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 50, BrettParser.RULE_property);
+	    try {
+	        this.state = 331;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 54:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 325;
+	            this.match(BrettParser.IDENTIFIER);
+	            this.state = 326;
+	            this.match(BrettParser.COLON);
+	            this.state = 327;
+	            this.expression(0);
+	            break;
+	        case 31:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 328;
+	            this.match(BrettParser.STRING);
+	            this.state = 329;
+	            this.match(BrettParser.COLON);
+	            this.state = 330;
+	            this.expression(0);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	argList() {
+	    let localctx = new ArgListContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 52, BrettParser.RULE_argList);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 333;
+	        this.expression(0);
+	        this.state = 338;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===45) {
+	            this.state = 334;
+	            this.match(BrettParser.COMMA);
+	            this.state = 335;
+	            this.expression(0);
+	            this.state = 340;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+}
+
+BrettParser.EOF = antlr4.Token.EOF;
+BrettParser.T__0 = 1;
+BrettParser.T__1 = 2;
+BrettParser.T__2 = 3;
+BrettParser.T__3 = 4;
+BrettParser.T__4 = 5;
+BrettParser.T__5 = 6;
+BrettParser.T__6 = 7;
+BrettParser.T__7 = 8;
+BrettParser.T__8 = 9;
+BrettParser.T__9 = 10;
+BrettParser.LET = 11;
+BrettParser.CONST = 12;
+BrettParser.DEF = 13;
+BrettParser.IF = 14;
+BrettParser.ELSE = 15;
+BrettParser.WHILE = 16;
+BrettParser.FOR = 17;
+BrettParser.DO = 18;
+BrettParser.TRY = 19;
+BrettParser.CATCH = 20;
+BrettParser.FINALLY = 21;
+BrettParser.BREAK = 22;
+BrettParser.CONTINUE = 23;
+BrettParser.NEW = 24;
+BrettParser.VOID = 25;
+BrettParser.SWITCH = 26;
+BrettParser.CASE = 27;
+BrettParser.DEFAULT = 28;
+BrettParser.RETURN = 29;
+BrettParser.NUMBER = 30;
+BrettParser.STRING = 31;
+BrettParser.EQ = 32;
+BrettParser.NEQ = 33;
+BrettParser.LE = 34;
+BrettParser.GE = 35;
+BrettParser.LT = 36;
+BrettParser.GT = 37;
+BrettParser.PLUS = 38;
+BrettParser.MINUS = 39;
+BrettParser.STAR = 40;
+BrettParser.SLASH = 41;
+BrettParser.ASSIGN = 42;
+BrettParser.SEMI = 43;
+BrettParser.COLON = 44;
+BrettParser.COMMA = 45;
+BrettParser.DOT = 46;
+BrettParser.LPAREN = 47;
+BrettParser.RPAREN = 48;
+BrettParser.LBRACE = 49;
+BrettParser.RBRACE = 50;
+BrettParser.LBRACK = 51;
+BrettParser.RBRACK = 52;
+BrettParser.ARROW = 53;
+BrettParser.IDENTIFIER = 54;
+BrettParser.WS = 55;
+BrettParser.LINE_COMMENT = 56;
+BrettParser.BLOCK_COMMENT = 57;
+
+BrettParser.RULE_program = 0;
+BrettParser.RULE_statement = 1;
+BrettParser.RULE_block = 2;
+BrettParser.RULE_variableDeclaration = 3;
+BrettParser.RULE_ifStatement = 4;
+BrettParser.RULE_whileStatement = 5;
+BrettParser.RULE_doWhileStatement = 6;
+BrettParser.RULE_forStatement = 7;
+BrettParser.RULE_switchStatement = 8;
+BrettParser.RULE_switchCase = 9;
+BrettParser.RULE_defaultCase = 10;
+BrettParser.RULE_returnStatement = 11;
+BrettParser.RULE_breakStatement = 12;
+BrettParser.RULE_continueStatement = 13;
+BrettParser.RULE_expressionStatement = 14;
+BrettParser.RULE_functionDeclaration = 15;
+BrettParser.RULE_parameterList = 16;
+BrettParser.RULE_parameter = 17;
+BrettParser.RULE_type = 18;
+BrettParser.RULE_baseType = 19;
+BrettParser.RULE_tryCatchStatement = 20;
+BrettParser.RULE_expression = 21;
+BrettParser.RULE_primary = 22;
+BrettParser.RULE_arrayLiteral = 23;
+BrettParser.RULE_objectLiteral = 24;
+BrettParser.RULE_property = 25;
+BrettParser.RULE_argList = 26;
+
+class ProgramContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_program;
+    }
+
+	EOF() {
+	    return this.getToken(BrettParser.EOF, 0);
+	};
+
+	statement = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(StatementContext);
+	    } else {
+	        return this.getTypedRuleContext(StatementContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterProgram(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitProgram(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitProgram(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class StatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_statement;
+    }
+
+	variableDeclaration() {
+	    return this.getTypedRuleContext(VariableDeclarationContext,0);
+	};
+
+	functionDeclaration() {
+	    return this.getTypedRuleContext(FunctionDeclarationContext,0);
+	};
+
+	ifStatement() {
+	    return this.getTypedRuleContext(IfStatementContext,0);
+	};
+
+	whileStatement() {
+	    return this.getTypedRuleContext(WhileStatementContext,0);
+	};
+
+	forStatement() {
+	    return this.getTypedRuleContext(ForStatementContext,0);
+	};
+
+	switchStatement() {
+	    return this.getTypedRuleContext(SwitchStatementContext,0);
+	};
+
+	returnStatement() {
+	    return this.getTypedRuleContext(ReturnStatementContext,0);
+	};
+
+	expressionStatement() {
+	    return this.getTypedRuleContext(ExpressionStatementContext,0);
+	};
+
+	block() {
+	    return this.getTypedRuleContext(BlockContext,0);
+	};
+
+	breakStatement() {
+	    return this.getTypedRuleContext(BreakStatementContext,0);
+	};
+
+	continueStatement() {
+	    return this.getTypedRuleContext(ContinueStatementContext,0);
+	};
+
+	doWhileStatement() {
+	    return this.getTypedRuleContext(DoWhileStatementContext,0);
+	};
+
+	tryCatchStatement() {
+	    return this.getTypedRuleContext(TryCatchStatementContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class BlockContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_block;
+    }
+
+	LBRACE() {
+	    return this.getToken(BrettParser.LBRACE, 0);
+	};
+
+	RBRACE() {
+	    return this.getToken(BrettParser.RBRACE, 0);
+	};
+
+	statement = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(StatementContext);
+	    } else {
+	        return this.getTypedRuleContext(StatementContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterBlock(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitBlock(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitBlock(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class VariableDeclarationContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_variableDeclaration;
+    }
+
+	LET() {
+	    return this.getToken(BrettParser.LET, 0);
+	};
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	SEMI() {
+	    return this.getToken(BrettParser.SEMI, 0);
+	};
+
+	COLON() {
+	    return this.getToken(BrettParser.COLON, 0);
+	};
+
+	type() {
+	    return this.getTypedRuleContext(TypeContext,0);
+	};
+
+	ASSIGN() {
+	    return this.getToken(BrettParser.ASSIGN, 0);
+	};
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	CONST() {
+	    return this.getToken(BrettParser.CONST, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterVariableDeclaration(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitVariableDeclaration(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitVariableDeclaration(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class IfStatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_ifStatement;
+    }
+
+	IF() {
+	    return this.getToken(BrettParser.IF, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(BrettParser.LPAREN, 0);
+	};
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	RPAREN() {
+	    return this.getToken(BrettParser.RPAREN, 0);
+	};
+
+	block = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(BlockContext);
+	    } else {
+	        return this.getTypedRuleContext(BlockContext,i);
+	    }
+	};
+
+	ELSE() {
+	    return this.getToken(BrettParser.ELSE, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterIfStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitIfStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitIfStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class WhileStatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_whileStatement;
+    }
+
+	WHILE() {
+	    return this.getToken(BrettParser.WHILE, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(BrettParser.LPAREN, 0);
+	};
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	RPAREN() {
+	    return this.getToken(BrettParser.RPAREN, 0);
+	};
+
+	block() {
+	    return this.getTypedRuleContext(BlockContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterWhileStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitWhileStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitWhileStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class DoWhileStatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_doWhileStatement;
+    }
+
+	DO() {
+	    return this.getToken(BrettParser.DO, 0);
+	};
+
+	block() {
+	    return this.getTypedRuleContext(BlockContext,0);
+	};
+
+	WHILE() {
+	    return this.getToken(BrettParser.WHILE, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(BrettParser.LPAREN, 0);
+	};
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	RPAREN() {
+	    return this.getToken(BrettParser.RPAREN, 0);
+	};
+
+	SEMI() {
+	    return this.getToken(BrettParser.SEMI, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterDoWhileStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitDoWhileStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitDoWhileStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ForStatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_forStatement;
+    }
+
+	FOR() {
+	    return this.getToken(BrettParser.FOR, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(BrettParser.LPAREN, 0);
+	};
+
+	SEMI() {
+	    return this.getToken(BrettParser.SEMI, 0);
+	};
+
+	RPAREN() {
+	    return this.getToken(BrettParser.RPAREN, 0);
+	};
+
+	block() {
+	    return this.getTypedRuleContext(BlockContext,0);
+	};
+
+	variableDeclaration() {
+	    return this.getTypedRuleContext(VariableDeclarationContext,0);
+	};
+
+	expressionStatement() {
+	    return this.getTypedRuleContext(ExpressionStatementContext,0);
+	};
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterForStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitForStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitForStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class SwitchStatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_switchStatement;
+    }
+
+	SWITCH() {
+	    return this.getToken(BrettParser.SWITCH, 0);
+	};
+
+	LBRACE() {
+	    return this.getToken(BrettParser.LBRACE, 0);
+	};
+
+	RBRACE() {
+	    return this.getToken(BrettParser.RBRACE, 0);
+	};
+
+	switchCase = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(SwitchCaseContext);
+	    } else {
+	        return this.getTypedRuleContext(SwitchCaseContext,i);
+	    }
+	};
+
+	defaultCase() {
+	    return this.getTypedRuleContext(DefaultCaseContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterSwitchStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitSwitchStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitSwitchStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class SwitchCaseContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_switchCase;
+    }
+
+	CASE() {
+	    return this.getToken(BrettParser.CASE, 0);
+	};
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	ARROW() {
+	    return this.getToken(BrettParser.ARROW, 0);
+	};
+
+	block() {
+	    return this.getTypedRuleContext(BlockContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterSwitchCase(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitSwitchCase(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitSwitchCase(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class DefaultCaseContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_defaultCase;
+    }
+
+	DEFAULT() {
+	    return this.getToken(BrettParser.DEFAULT, 0);
+	};
+
+	ARROW() {
+	    return this.getToken(BrettParser.ARROW, 0);
+	};
+
+	block() {
+	    return this.getTypedRuleContext(BlockContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterDefaultCase(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitDefaultCase(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitDefaultCase(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ReturnStatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_returnStatement;
+    }
+
+	RETURN() {
+	    return this.getToken(BrettParser.RETURN, 0);
+	};
+
+	SEMI() {
+	    return this.getToken(BrettParser.SEMI, 0);
+	};
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterReturnStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitReturnStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitReturnStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class BreakStatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_breakStatement;
+    }
+
+	BREAK() {
+	    return this.getToken(BrettParser.BREAK, 0);
+	};
+
+	SEMI() {
+	    return this.getToken(BrettParser.SEMI, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterBreakStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitBreakStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitBreakStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ContinueStatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_continueStatement;
+    }
+
+	CONTINUE() {
+	    return this.getToken(BrettParser.CONTINUE, 0);
+	};
+
+	SEMI() {
+	    return this.getToken(BrettParser.SEMI, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterContinueStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitContinueStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitContinueStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ExpressionStatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_expressionStatement;
+    }
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	SEMI() {
+	    return this.getToken(BrettParser.SEMI, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterExpressionStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitExpressionStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitExpressionStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class FunctionDeclarationContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_functionDeclaration;
+    }
+
+	DEF() {
+	    return this.getToken(BrettParser.DEF, 0);
+	};
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(BrettParser.LPAREN, 0);
+	};
+
+	RPAREN() {
+	    return this.getToken(BrettParser.RPAREN, 0);
+	};
+
+	block() {
+	    return this.getTypedRuleContext(BlockContext,0);
+	};
+
+	parameterList() {
+	    return this.getTypedRuleContext(ParameterListContext,0);
+	};
+
+	COLON() {
+	    return this.getToken(BrettParser.COLON, 0);
+	};
+
+	type() {
+	    return this.getTypedRuleContext(TypeContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterFunctionDeclaration(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitFunctionDeclaration(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitFunctionDeclaration(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ParameterListContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_parameterList;
+    }
+
+	parameter = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ParameterContext);
+	    } else {
+	        return this.getTypedRuleContext(ParameterContext,i);
+	    }
+	};
+
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(BrettParser.COMMA);
+	    } else {
+	        return this.getToken(BrettParser.COMMA, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterParameterList(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitParameterList(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitParameterList(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ParameterContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_parameter;
+    }
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	COLON() {
+	    return this.getToken(BrettParser.COLON, 0);
+	};
+
+	type() {
+	    return this.getTypedRuleContext(TypeContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterParameter(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitParameter(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitParameter(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class TypeContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_type;
+    }
+
+
+	 
+		copyFrom(ctx) {
+			super.copyFrom(ctx);
+		}
+
+}
+
+
+class ArrayTypeContext extends TypeContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	type() {
+	    return this.getTypedRuleContext(TypeContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterArrayType(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitArrayType(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitArrayType(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.ArrayTypeContext = ArrayTypeContext;
+
+class SimpleTypeContext extends TypeContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	baseType() {
+	    return this.getTypedRuleContext(BaseTypeContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterSimpleType(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitSimpleType(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitSimpleType(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.SimpleTypeContext = SimpleTypeContext;
+
+class BaseTypeContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_baseType;
+    }
+
+	VOID() {
+	    return this.getToken(BrettParser.VOID, 0);
+	};
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterBaseType(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitBaseType(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitBaseType(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class TryCatchStatementContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_tryCatchStatement;
+    }
+
+	TRY() {
+	    return this.getToken(BrettParser.TRY, 0);
+	};
+
+	block = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(BlockContext);
+	    } else {
+	        return this.getTypedRuleContext(BlockContext,i);
+	    }
+	};
+
+	CATCH() {
+	    return this.getToken(BrettParser.CATCH, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(BrettParser.LPAREN, 0);
+	};
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	RPAREN() {
+	    return this.getToken(BrettParser.RPAREN, 0);
+	};
+
+	COLON() {
+	    return this.getToken(BrettParser.COLON, 0);
+	};
+
+	type() {
+	    return this.getTypedRuleContext(TypeContext,0);
+	};
+
+	FINALLY() {
+	    return this.getToken(BrettParser.FINALLY, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterTryCatchStatement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitTryCatchStatement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitTryCatchStatement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_expression;
+    }
+
+
+	 
+		copyFrom(ctx) {
+			super.copyFrom(ctx);
+		}
+
+}
+
+
+class MemberExpressionContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	DOT() {
+	    return this.getToken(BrettParser.DOT, 0);
+	};
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterMemberExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitMemberExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitMemberExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.MemberExpressionContext = MemberExpressionContext;
+
+class PrimaryExpressionContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	primary() {
+	    return this.getTypedRuleContext(PrimaryContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterPrimaryExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitPrimaryExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitPrimaryExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.PrimaryExpressionContext = PrimaryExpressionContext;
+
+class AssignmentExpressionContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	ASSIGN() {
+	    return this.getToken(BrettParser.ASSIGN, 0);
+	};
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterAssignmentExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitAssignmentExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitAssignmentExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.AssignmentExpressionContext = AssignmentExpressionContext;
+
+class BinaryExpressionContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        this.op = null;;
+        super.copyFrom(ctx);
+    }
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	STAR() {
+	    return this.getToken(BrettParser.STAR, 0);
+	};
+
+	SLASH() {
+	    return this.getToken(BrettParser.SLASH, 0);
+	};
+
+	PLUS() {
+	    return this.getToken(BrettParser.PLUS, 0);
+	};
+
+	MINUS() {
+	    return this.getToken(BrettParser.MINUS, 0);
+	};
+
+	LT() {
+	    return this.getToken(BrettParser.LT, 0);
+	};
+
+	LE() {
+	    return this.getToken(BrettParser.LE, 0);
+	};
+
+	GT() {
+	    return this.getToken(BrettParser.GT, 0);
+	};
+
+	GE() {
+	    return this.getToken(BrettParser.GE, 0);
+	};
+
+	EQ() {
+	    return this.getToken(BrettParser.EQ, 0);
+	};
+
+	NEQ() {
+	    return this.getToken(BrettParser.NEQ, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterBinaryExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitBinaryExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitBinaryExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.BinaryExpressionContext = BinaryExpressionContext;
+
+class NewExpressionContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	NEW() {
+	    return this.getToken(BrettParser.NEW, 0);
+	};
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(BrettParser.LPAREN, 0);
+	};
+
+	RPAREN() {
+	    return this.getToken(BrettParser.RPAREN, 0);
+	};
+
+	argList() {
+	    return this.getTypedRuleContext(ArgListContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterNewExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitNewExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitNewExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.NewExpressionContext = NewExpressionContext;
+
+class PreIncrementDecrementContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterPreIncrementDecrement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitPreIncrementDecrement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitPreIncrementDecrement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.PreIncrementDecrementContext = PreIncrementDecrementContext;
+
+class IndexExpressionContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	LBRACK() {
+	    return this.getToken(BrettParser.LBRACK, 0);
+	};
+
+	RBRACK() {
+	    return this.getToken(BrettParser.RBRACK, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterIndexExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitIndexExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitIndexExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.IndexExpressionContext = IndexExpressionContext;
+
+class PostIncrementDecrementContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterPostIncrementDecrement(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitPostIncrementDecrement(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitPostIncrementDecrement(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.PostIncrementDecrementContext = PostIncrementDecrementContext;
+
+class PrimaryContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_primary;
+    }
+
+
+	 
+		copyFrom(ctx) {
+			super.copyFrom(ctx);
+		}
+
+}
+
+
+class ParenthesizedExpressionContext extends PrimaryContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	LPAREN() {
+	    return this.getToken(BrettParser.LPAREN, 0);
+	};
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	RPAREN() {
+	    return this.getToken(BrettParser.RPAREN, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterParenthesizedExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitParenthesizedExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitParenthesizedExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.ParenthesizedExpressionContext = ParenthesizedExpressionContext;
+
+class ObjectLiteralExpressionContext extends PrimaryContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	objectLiteral() {
+	    return this.getTypedRuleContext(ObjectLiteralContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterObjectLiteralExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitObjectLiteralExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitObjectLiteralExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.ObjectLiteralExpressionContext = ObjectLiteralExpressionContext;
+
+class LiteralExpressionContext extends PrimaryContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	NUMBER() {
+	    return this.getToken(BrettParser.NUMBER, 0);
+	};
+
+	STRING() {
+	    return this.getToken(BrettParser.STRING, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterLiteralExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitLiteralExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitLiteralExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.LiteralExpressionContext = LiteralExpressionContext;
+
+class ArrayLiteralExpressionContext extends PrimaryContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	arrayLiteral() {
+	    return this.getTypedRuleContext(ArrayLiteralContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterArrayLiteralExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitArrayLiteralExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitArrayLiteralExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.ArrayLiteralExpressionContext = ArrayLiteralExpressionContext;
+
+class FunctionCallExpressionContext extends PrimaryContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	LPAREN() {
+	    return this.getToken(BrettParser.LPAREN, 0);
+	};
+
+	RPAREN() {
+	    return this.getToken(BrettParser.RPAREN, 0);
+	};
+
+	argList() {
+	    return this.getTypedRuleContext(ArgListContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterFunctionCallExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitFunctionCallExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitFunctionCallExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.FunctionCallExpressionContext = FunctionCallExpressionContext;
+
+class IdentifierExpressionContext extends PrimaryContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterIdentifierExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitIdentifierExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitIdentifierExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+BrettParser.IdentifierExpressionContext = IdentifierExpressionContext;
+
+class ArrayLiteralContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_arrayLiteral;
+    }
+
+	LBRACK() {
+	    return this.getToken(BrettParser.LBRACK, 0);
+	};
+
+	RBRACK() {
+	    return this.getToken(BrettParser.RBRACK, 0);
+	};
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(BrettParser.COMMA);
+	    } else {
+	        return this.getToken(BrettParser.COMMA, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterArrayLiteral(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitArrayLiteral(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitArrayLiteral(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ObjectLiteralContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_objectLiteral;
+    }
+
+	LBRACE() {
+	    return this.getToken(BrettParser.LBRACE, 0);
+	};
+
+	RBRACE() {
+	    return this.getToken(BrettParser.RBRACE, 0);
+	};
+
+	property = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(PropertyContext);
+	    } else {
+	        return this.getTypedRuleContext(PropertyContext,i);
+	    }
+	};
+
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(BrettParser.COMMA);
+	    } else {
+	        return this.getToken(BrettParser.COMMA, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterObjectLiteral(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitObjectLiteral(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitObjectLiteral(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class PropertyContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_property;
+    }
+
+	IDENTIFIER() {
+	    return this.getToken(BrettParser.IDENTIFIER, 0);
+	};
+
+	COLON() {
+	    return this.getToken(BrettParser.COLON, 0);
+	};
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	STRING() {
+	    return this.getToken(BrettParser.STRING, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterProperty(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitProperty(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitProperty(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ArgListContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = BrettParser.RULE_argList;
+    }
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(BrettParser.COMMA);
+	    } else {
+	        return this.getToken(BrettParser.COMMA, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.enterArgList(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof BrettListener ) {
+	        listener.exitArgList(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof BrettVisitor ) {
+	        return visitor.visitArgList(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+
+BrettParser.ProgramContext = ProgramContext; 
+BrettParser.StatementContext = StatementContext; 
+BrettParser.BlockContext = BlockContext; 
+BrettParser.VariableDeclarationContext = VariableDeclarationContext; 
+BrettParser.IfStatementContext = IfStatementContext; 
+BrettParser.WhileStatementContext = WhileStatementContext; 
+BrettParser.DoWhileStatementContext = DoWhileStatementContext; 
+BrettParser.ForStatementContext = ForStatementContext; 
+BrettParser.SwitchStatementContext = SwitchStatementContext; 
+BrettParser.SwitchCaseContext = SwitchCaseContext; 
+BrettParser.DefaultCaseContext = DefaultCaseContext; 
+BrettParser.ReturnStatementContext = ReturnStatementContext; 
+BrettParser.BreakStatementContext = BreakStatementContext; 
+BrettParser.ContinueStatementContext = ContinueStatementContext; 
+BrettParser.ExpressionStatementContext = ExpressionStatementContext; 
+BrettParser.FunctionDeclarationContext = FunctionDeclarationContext; 
+BrettParser.ParameterListContext = ParameterListContext; 
+BrettParser.ParameterContext = ParameterContext; 
+BrettParser.TypeContext = TypeContext; 
+BrettParser.BaseTypeContext = BaseTypeContext; 
+BrettParser.TryCatchStatementContext = TryCatchStatementContext; 
+BrettParser.ExpressionContext = ExpressionContext; 
+BrettParser.PrimaryContext = PrimaryContext; 
+BrettParser.ArrayLiteralContext = ArrayLiteralContext; 
+BrettParser.ObjectLiteralContext = ObjectLiteralContext; 
+BrettParser.PropertyContext = PropertyContext; 
+BrettParser.ArgListContext = ArgListContext;