brighterscript 1.0.0-alpha.2 → 1.0.0-alpha.22

package/dist/parser/Expression.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NullCoalescingExpression = exports.TernaryExpression = exports.AnnotationExpression = exports.TaggedTemplateStringExpression = exports.TemplateStringExpression = exports.TemplateStringQuasiExpression = exports.CallfuncExpression = exports.NewExpression = exports.SourceLiteralExpression = exports.VariableExpression = exports.UnaryExpression = exports.AALiteralExpression = exports.AAMemberExpression = exports.ArrayLiteralExpression = exports.EscapedCharCodeLiteralExpression = exports.LiteralExpression = exports.GroupingExpression = exports.IndexedGetExpression = exports.XmlAttributeGetExpression = exports.DottedGetExpression = exports.NamespacedVariableNameExpression = exports.FunctionParameterExpression = exports.FunctionExpression = exports.CallExpression = exports.BinaryExpression = exports.Expression = void 0;
-const lexer_1 = require("../lexer");
+exports.ArrayTypeExpression = exports.TypeExpression = exports.RegexLiteralExpression = exports.NullCoalescingExpression = exports.TernaryExpression = exports.AnnotationExpression = exports.TaggedTemplateStringExpression = exports.TemplateStringExpression = exports.TemplateStringQuasiExpression = exports.CallfuncExpression = exports.NewExpression = exports.SourceLiteralExpression = exports.VariableExpression = exports.UnaryExpression = exports.AALiteralExpression = exports.AAMemberExpression = exports.ArrayLiteralExpression = exports.EscapedCharCodeLiteralExpression = exports.LiteralExpression = exports.GroupingExpression = exports.IndexedGetExpression = exports.XmlAttributeGetExpression = exports.DottedGetExpression = exports.NamespacedVariableNameExpression = exports.FunctionParameterExpression = exports.FunctionExpression = exports.CallExpression = exports.BinaryExpression = exports.Expression = void 0;
+const TokenKind_1 = require("../lexer/TokenKind");
 const util_1 = require("../util");
 const Parser_1 = require("./Parser");
 const fileUrl = require("file-url");
@@ -10,7 +10,9 @@ const reflection_1 = require("../astUtils/reflection");
 const VoidType_1 = require("../types/VoidType");
 const DynamicType_1 = require("../types/DynamicType");
 const SymbolTable_1 = require("../SymbolTable");
-const FunctionType_1 = require("../types/FunctionType");
+const TypedFunctionType_1 = require("../types/TypedFunctionType");
+const ObjectType_1 = require("../types/ObjectType");
+const ArrayType_1 = require("../types/ArrayType");
 /** A BrightScript expression */
 class Expression {
     constructor() {
@@ -27,7 +29,7 @@ class BinaryExpression extends Expression {
         this.left = left;
         this.operator = operator;
         this.right = right;
-        this.range = util_1.default.createRangeFromPositions(this.left.range.start, this.right.range.end);
+        this.range = util_1.default.createBoundingRange(this.left, this.right);
     }
     transpile(state) {
         return [
@@ -40,14 +42,18 @@ class BinaryExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'left', visitor, options);
-            visitors_1.walk(this, 'right', visitor, options);
+            (0, visitors_1.walk)(this, 'left', visitor, options);
+            (0, visitors_1.walk)(this, 'right', visitor, options);
         }
     }
 }
 exports.BinaryExpression = BinaryExpression;
 class CallExpression extends Expression {
-    constructor(callee, openingParen, closingParen, args, 
+    constructor(callee, 
+    /**
+     * Can either be `(`, or `?(` for optional chaining
+     */
+    openingParen, closingParen, args, 
     /**
      * The namespace that currently wraps this call expression. This is NOT the namespace of the callee...that will be represented in the callee expression itself.
      */
@@ -58,7 +64,7 @@ class CallExpression extends Expression {
         this.closingParen = closingParen;
         this.args = args;
         this.namespaceName = namespaceName;
-        this.range = util_1.default.createRangeFromPositions(this.callee.range.start, this.closingParen.range.end);
+        this.range = util_1.default.createBoundingRange(this.callee, this.closingParen);
     }
     transpile(state, nameOverride) {
         let result = [];
@@ -83,17 +89,15 @@ class CallExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'callee', visitor, options);
-            for (let i = 0; i < this.args.length; i++) {
-                visitors_1.walk(this.args, i, visitor, options, this);
-            }
+            (0, visitors_1.walk)(this, 'callee', visitor, options);
+            (0, visitors_1.walkArray)(this.args, visitor, options, this);
         }
     }
 }
 exports.CallExpression = CallExpression;
-CallExpression.MaximumArguments = 32;
+CallExpression.MaximumArguments = util_1.MAX_PARAM_COUNT;
 class FunctionExpression extends Expression {
-    constructor(parameters, body, functionType, end, leftParen, rightParen, asToken, returnTypeToken, 
+    constructor(parameters, body, functionType, end, leftParen, rightParen, asToken, returnType, 
     /**
      * If this function is enclosed within another function, this will reference that parent function
      */
@@ -106,7 +110,7 @@ class FunctionExpression extends Expression {
         this.leftParen = leftParen;
         this.rightParen = rightParen;
         this.asToken = asToken;
-        this.returnTypeToken = returnTypeToken;
+        this.returnType = returnType;
         this.parentFunction = parentFunction;
         this.namespaceName = namespaceName;
         this.parentSymbolTable = parentSymbolTable;
@@ -120,27 +124,46 @@ class FunctionExpression extends Expression {
          * A list of all child functions declared directly within this function
          */
         this.childFunctionExpressions = [];
-        if (this.returnTypeToken) {
-            this.returnType = util_1.default.tokenToBscType(this.returnTypeToken);
+        if (this.returnType) {
+            this._returnType = this.returnType.type;
         }
         else if (this.functionType.text.toLowerCase() === 'sub') {
-            this.returnType = new VoidType_1.VoidType();
+            this._returnType = new VoidType_1.VoidType();
         }
         else {
-            this.returnType = new DynamicType_1.DynamicType();
+            this._returnType = new DynamicType_1.DynamicType();
         }
         this.symbolTable = new SymbolTable_1.SymbolTable(parentSymbolTable);
         for (let param of parameters) {
-            this.symbolTable.addSymbol(param.name.text, param.name.range, param.type);
+            this.symbolTable.addSymbol(param.name.text, param.name.range, param.getType());
         }
     }
+    get range() {
+        return this.cacheRange();
+    }
     /**
-     * The range of the function, starting at the 'f' in function or 's' in sub (or the open paren if the keyword is missing),
-     * and ending with the last n' in 'end function' or 'b' in 'end sub'
+     * The range of the function
      */
-    get range() {
-        var _a, _b, _c, _d, _e;
-        return util_1.default.createRangeFromPositions(((_a = this.functionType) !== null && _a !== void 0 ? _a : this.leftParen).range.start, ((_e = (_d = (_c = (_b = this.end) !== null && _b !== void 0 ? _b : this.body) !== null && _c !== void 0 ? _c : this.returnTypeToken) !== null && _d !== void 0 ? _d : this.asToken) !== null && _e !== void 0 ? _e : this.rightParen).range.end);
+    cacheRange() {
+        var _a;
+        if (!this._range) {
+            this._range = util_1.default.createBoundingRange(this.functionType, this.leftParen, ...((_a = this.parameters) !== null && _a !== void 0 ? _a : []), this.rightParen, this.asToken, this.returnType, this.body, this.end);
+        }
+        return this._range;
+    }
+    /**
+     * The type this function returns
+     */
+    getReturnType() {
+        return this._returnType;
+    }
+    /**
+    * The range of the function declaration, starting at the 'f' in function or 's' in sub (or the open paren if the keyword is missing),
+    * and ending with the last character in the returnTypeToken, or the 's' in 'as', or the rightParen
+    */
+    get functionDeclarationRange() {
+        var _a;
+        return util_1.default.createBoundingRange(this.functionType, this.leftParen, ...((_a = this.parameters) !== null && _a !== void 0 ? _a : []), this.rightParen, this.asToken, this.returnType);
     }
     transpile(state, name, includeBody = true) {
         let results = [];
@@ -170,7 +193,7 @@ class FunctionExpression extends Expression {
             //as
             state.transpileToken(this.asToken), ' ', 
             //return type
-            state.sourceNode(this.returnTypeToken, this.returnType.toTypeString()));
+            state.sourceNode(this.returnType, this.getReturnType().toTypeString(state.typeContext)));
         }
         if (includeBody) {
             state.lineage.unshift(this);
@@ -178,9 +201,11 @@ class FunctionExpression extends Expression {
             state.lineage.shift();
             results.push(...body);
         }
-        results.push('\n');
-        //'end sub'|'end function'
-        results.push(state.indent(), state.transpileToken(this.end));
+        if (this.end) {
+            results.push('\n');
+            //'end sub'|'end function'
+            results.push(state.indent(), state.transpileToken(this.end));
+        }
         return results;
     }
     getTypedef(state, name) {
@@ -188,43 +213,38 @@ class FunctionExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            for (let i = 0; i < this.parameters.length; i++) {
-                visitors_1.walk(this.parameters, i, visitor, options, this);
-            }
+            (0, visitors_1.walkArray)(this.parameters, visitor, options, this);
             //This is the core of full-program walking...it allows us to step into sub functions
             if (options.walkMode & visitors_1.InternalWalkMode.recurseChildFunctions) {
-                visitors_1.walk(this, 'body', visitor, options);
+                (0, visitors_1.walk)(this, 'returnType', visitor, options);
+                (0, visitors_1.walk)(this, 'body', visitor, options);
             }
         }
     }
     getFunctionType() {
-        let functionType = new FunctionType_1.FunctionType(this.returnType);
+        let functionType = new TypedFunctionType_1.TypedFunctionType(this.getReturnType());
         functionType.isSub = this.functionType.text === 'sub';
         for (let param of this.parameters) {
-            let isRequired = !param.defaultValue;
-            //TODO compute optional parameters
-            functionType.addParameter(param.name.text, param.type, isRequired);
+            functionType.addParameter(param.name.text, param.getType(), param.isOptional);
         }
         return functionType;
     }
 }
 exports.FunctionExpression = FunctionExpression;
 class FunctionParameterExpression extends Expression {
-    constructor(name, type, equalsToken, defaultValue, asToken, typeToken, namespaceName) {
+    constructor(name, typeInContext, equalsToken, defaultValue, asToken, type, namespaceName) {
         super();
         this.name = name;
-        this.type = type;
+        this.typeInContext = typeInContext;
         this.equalsToken = equalsToken;
         this.defaultValue = defaultValue;
         this.asToken = asToken;
-        this.typeToken = typeToken;
+        this.type = type;
         this.namespaceName = namespaceName;
+        this.range = util_1.default.createBoundingRange(this.name, this.equalsToken, this.defaultValue, this.asToken, this.type);
     }
-    get range() {
-        return {
-            start: this.name.range.start,
-            end: this.typeToken ? this.typeToken.range.end : this.name.range.end
-        };
+    getType() {
+        return this.typeInContext;
     }
     transpile(state) {
         let result = [
@@ -241,16 +261,20 @@ class FunctionParameterExpression extends Expression {
             result.push(' ');
             result.push(state.transpileToken(this.asToken));
             result.push(' ');
-            result.push(state.sourceNode(this.typeToken, this.type.toTypeString()));
+            result.push(state.sourceNode(this.type, this.getType().toTypeString(state.typeContext)));
         }
         return result;
     }
     walk(visitor, options) {
         // eslint-disable-next-line no-bitwise
         if (this.defaultValue && options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'defaultValue', visitor, options);
+            (0, visitors_1.walk)(this, 'defaultValue', visitor, options);
+            (0, visitors_1.walk)(this, 'type', visitor, options);
         }
     }
+    get isOptional() {
+        return !!this.defaultValue;
+    }
 }
 exports.FunctionParameterExpression = FunctionParameterExpression;
 class NamespacedVariableNameExpression extends Expression {
@@ -268,20 +292,20 @@ class NamespacedVariableNameExpression extends Expression {
     }
     getNameParts() {
         let parts = [];
-        if (reflection_1.isVariableExpression(this.expression)) {
+        if ((0, reflection_1.isVariableExpression)(this.expression)) {
             parts.push(this.expression.name.text);
         }
         else {
             let expr = this.expression;
             parts.push(expr.name.text);
-            while (reflection_1.isVariableExpression(expr) === false) {
+            while ((0, reflection_1.isVariableExpression)(expr) === false) {
                 expr = expr.obj;
                 parts.unshift(expr.name.text);
             }
         }
         return parts;
     }
-    getName(parseMode) {
+    getName(parseMode = Parser_1.ParseMode.BrighterScript) {
         if (parseMode === Parser_1.ParseMode.BrighterScript) {
             return this.getNameParts().join('.');
         }
@@ -291,18 +315,22 @@ class NamespacedVariableNameExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'expression', visitor, options);
+            (0, visitors_1.walk)(this, 'expression', visitor, options);
         }
     }
 }
 exports.NamespacedVariableNameExpression = NamespacedVariableNameExpression;
 class DottedGetExpression extends Expression {
-    constructor(obj, name, dot) {
+    constructor(obj, name, 
+    /**
+     * Can either be `.`, or `?.` for optional chaining
+     */
+    dot) {
         super();
         this.obj = obj;
         this.name = name;
         this.dot = dot;
-        this.range = util_1.default.createRangeFromPositions(this.obj.range.start, this.name.range.end);
+        this.range = util_1.default.createBoundingRange(this.obj, this.dot, this.name);
     }
     transpile(state) {
         //if the callee starts with a namespace name, transpile the name
@@ -312,52 +340,63 @@ class DottedGetExpression extends Expression {
         else {
             return [
                 ...this.obj.transpile(state),
-                '.',
+                state.transpileToken(this.dot),
                 state.transpileToken(this.name)
             ];
         }
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'obj', visitor, options);
+            (0, visitors_1.walk)(this, 'obj', visitor, options);
         }
     }
 }
 exports.DottedGetExpression = DottedGetExpression;
 class XmlAttributeGetExpression extends Expression {
-    constructor(obj, name, at) {
+    constructor(obj, name, 
+    /**
+     * Can either be `@`, or `?@` for optional chaining
+     */
+    at) {
         super();
         this.obj = obj;
         this.name = name;
         this.at = at;
-        this.range = util_1.default.createRangeFromPositions(this.obj.range.start, this.name.range.end);
+        this.range = util_1.default.createBoundingRange(this.obj, this.at, this.name);
     }
     transpile(state) {
         return [
             ...this.obj.transpile(state),
-            '@',
+            state.transpileToken(this.at),
             state.transpileToken(this.name)
         ];
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'obj', visitor, options);
+            (0, visitors_1.walk)(this, 'obj', visitor, options);
         }
     }
 }
 exports.XmlAttributeGetExpression = XmlAttributeGetExpression;
 class IndexedGetExpression extends Expression {
-    constructor(obj, index, openingSquare, closingSquare) {
+    constructor(obj, index, 
+    /**
+     * Can either be `[` or `?[`. If `?.[` is used, this will be `[` and `optionalChainingToken` will be `?.`
+     */
+    openingSquare, closingSquare, questionDotToken //  ? or ?.
+    ) {
         super();
         this.obj = obj;
         this.index = index;
         this.openingSquare = openingSquare;
         this.closingSquare = closingSquare;
-        this.range = util_1.default.createRangeFromPositions(this.obj.range.start, this.closingSquare.range.end);
+        this.questionDotToken = questionDotToken;
+        this.range = util_1.default.createBoundingRange(this.obj, this.openingSquare, this.questionDotToken, this.openingSquare, this.index, this.closingSquare);
     }
     transpile(state) {
         return [
             ...this.obj.transpile(state),
+            this.questionDotToken ? state.transpileToken(this.questionDotToken) : '',
             state.transpileToken(this.openingSquare),
             ...this.index.transpile(state),
             state.transpileToken(this.closingSquare)
@@ -365,8 +404,8 @@ class IndexedGetExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'obj', visitor, options);
-            visitors_1.walk(this, 'index', visitor, options);
+            (0, visitors_1.walk)(this, 'obj', visitor, options);
+            (0, visitors_1.walk)(this, 'index', visitor, options);
         }
     }
 }
@@ -376,7 +415,7 @@ class GroupingExpression extends Expression {
         super();
         this.tokens = tokens;
         this.expression = expression;
-        this.range = util_1.default.createRangeFromPositions(this.tokens.left.range.start, this.tokens.right.range.end);
+        this.range = util_1.default.createBoundingRange(this.tokens.left, this.expression, this.tokens.right);
     }
     transpile(state) {
         return [
@@ -387,7 +426,7 @@ class GroupingExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'expression', visitor, options);
+            (0, visitors_1.walk)(this, 'expression', visitor, options);
         }
     }
 }
@@ -396,18 +435,16 @@ class LiteralExpression extends Expression {
     constructor(token) {
         super();
         this.token = token;
+        this.range = this.token.range;
         this.type = util_1.default.tokenToBscType(token);
     }
-    get range() {
-        return this.token.range;
-    }
     transpile(state) {
         let text;
-        if (this.token.kind === lexer_1.TokenKind.TemplateStringQuasi) {
+        if (this.token.kind === TokenKind_1.TokenKind.TemplateStringQuasi) {
             //wrap quasis with quotes (and escape inner quotemarks)
             text = `"${this.token.text.replace(/"/g, '""')}"`;
         }
-        else if (reflection_1.isStringType(this.type)) {
+        else if ((0, reflection_1.isStringType)(this.type)) {
             text = this.token.text;
             //add trailing quotemark if it's missing. We will have already generated a diagnostic for this.
             if (text.endsWith('"') === false) {
@@ -448,12 +485,13 @@ class EscapedCharCodeLiteralExpression extends Expression {
 exports.EscapedCharCodeLiteralExpression = EscapedCharCodeLiteralExpression;
 class ArrayLiteralExpression extends Expression {
     constructor(elements, open, close, hasSpread = false) {
+        var _a;
         super();
         this.elements = elements;
         this.open = open;
         this.close = close;
         this.hasSpread = hasSpread;
-        this.range = util_1.default.createRangeFromPositions(this.open.range.start, this.close.range.end);
+        this.range = util_1.default.createBoundingRange(this.open, ...((_a = this.elements) !== null && _a !== void 0 ? _a : []), this.close);
     }
     transpile(state) {
         let result = [];
@@ -463,7 +501,7 @@ class ArrayLiteralExpression extends Expression {
         for (let i = 0; i < this.elements.length; i++) {
             let previousElement = this.elements[i - 1];
             let element = this.elements[i];
-            if (reflection_1.isCommentStatement(element)) {
+            if ((0, reflection_1.isCommentStatement)(element)) {
                 //if the comment is on the same line as opening square or previous statement, don't add newline
                 if (util_1.default.linesTouch(this.open, element) || util_1.default.linesTouch(previousElement, element)) {
                     result.push(' ');
@@ -478,15 +516,6 @@ class ArrayLiteralExpression extends Expression {
             else {
                 result.push('\n');
                 result.push(state.indent(), ...element.transpile(state));
-                //add a comma if we know there will be another non-comment statement after this
-                for (let j = i + 1; j < this.elements.length; j++) {
-                    let el = this.elements[j];
-                    //add a comma if there will be another element after this
-                    if (reflection_1.isCommentStatement(el) === false) {
-                        result.push(',');
-                        break;
-                    }
-                }
             }
         }
         state.blockDepth--;
@@ -500,9 +529,7 @@ class ArrayLiteralExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            for (let i = 0; i < this.elements.length; i++) {
-                visitors_1.walk(this.elements, i, visitor, options, this);
-            }
+            (0, visitors_1.walkArray)(this.elements, visitor, options, this);
         }
     }
 }
@@ -510,29 +537,44 @@ exports.ArrayLiteralExpression = ArrayLiteralExpression;
 class AAMemberExpression extends Expression {
     constructor(keyToken, colonToken, 
     /** The expression evaluated to determine the member's initial value. */
-    value) {
+    value, type) {
         super();
         this.keyToken = keyToken;
         this.colonToken = colonToken;
         this.value = value;
-        this.range = util_1.default.createRangeFromPositions(keyToken.range.start, this.value.range.end);
+        this.type = type;
+        this.range = util_1.default.createBoundingRange(this.keyToken, this.colonToken, this.value);
     }
     transpile(state) {
         //TODO move the logic from AALiteralExpression loop into this function
         return [];
     }
     walk(visitor, options) {
-        visitors_1.walk(this, 'value', visitor, options);
+        (0, visitors_1.walk)(this, 'value', visitor, options);
     }
 }
 exports.AAMemberExpression = AAMemberExpression;
 class AALiteralExpression extends Expression {
-    constructor(elements, open, close) {
+    constructor(elements, open, close, functionExpression) {
+        var _a;
         super();
         this.elements = elements;
         this.open = open;
         this.close = close;
-        this.range = util_1.default.createRangeFromPositions(this.open.range.start, this.close.range.end);
+        this.functionExpression = functionExpression;
+        this.symbolTable = new SymbolTable_1.SymbolTable();
+        this.memberTable = new SymbolTable_1.SymbolTable();
+        this.range = util_1.default.createBoundingRange(this.open, ...((_a = this.elements) !== null && _a !== void 0 ? _a : []), this.close);
+        this.buildSymbolTable();
+    }
+    buildSymbolTable() {
+        this.symbolTable.clear();
+        this.symbolTable.addSymbol('m', { start: this.open.range.start, end: this.close.range.end }, new ObjectType_1.ObjectType('object', this.memberTable));
+        for (const element of this.elements) {
+            if ((0, reflection_1.isAAMemberExpression)(element)) {
+                this.memberTable.addSymbol(element.keyToken.text, element.keyToken.range, (0, Parser_1.getBscTypeFromExpression)(element.value, this.functionExpression));
+            }
+        }
     }
     transpile(state) {
         let result = [];
@@ -540,7 +582,7 @@ class AALiteralExpression extends Expression {
         result.push(state.transpileToken(this.open));
         let hasChildren = this.elements.length > 0;
         //add newline if the object has children and the first child isn't a comment starting on the same line as opening curly
-        if (hasChildren && (reflection_1.isCommentStatement(this.elements[0]) === false || !util_1.default.linesTouch(this.elements[0], this.open))) {
+        if (hasChildren && ((0, reflection_1.isCommentStatement)(this.elements[0]) === false || !util_1.default.linesTouch(this.elements[0], this.open))) {
             result.push('\n');
         }
         state.blockDepth++;
@@ -549,7 +591,7 @@ class AALiteralExpression extends Expression {
             let previousElement = this.elements[i - 1];
             let nextElement = this.elements[i + 1];
             //don't indent if comment is same-line
-            if (reflection_1.isCommentStatement(element) &&
+            if ((0, reflection_1.isCommentStatement)(element) &&
                 (util_1.default.linesTouch(this.open, element) || util_1.default.linesTouch(previousElement, element))) {
                 result.push(' ');
                 //indent line
@@ -558,7 +600,7 @@ class AALiteralExpression extends Expression {
                 result.push(state.indent());
             }
             //render comments
-            if (reflection_1.isCommentStatement(element)) {
+            if ((0, reflection_1.isCommentStatement)(element)) {
                 result.push(...element.transpile(state));
             }
             else {
@@ -566,23 +608,11 @@ class AALiteralExpression extends Expression {
                 result.push(state.transpileToken(element.keyToken));
                 //colon
                 result.push(state.transpileToken(element.colonToken), ' ');
-                //determine if comments are the only members left in the array
-                let onlyCommentsRemaining = true;
-                for (let j = i + 1; j < this.elements.length; j++) {
-                    if (reflection_1.isCommentStatement(this.elements[j]) === false) {
-                        onlyCommentsRemaining = false;
-                        break;
-                    }
-                }
                 //value
                 result.push(...element.value.transpile(state));
-                //add trailing comma if not final element (excluding comments)
-                if (i !== this.elements.length - 1 && onlyCommentsRemaining === false) {
-                    result.push(',');
-                }
             }
             //if next element is a same-line comment, skip the newline
-            if (nextElement && reflection_1.isCommentStatement(nextElement) && nextElement.range.start.line === element.range.start.line) {
+            if (nextElement && (0, reflection_1.isCommentStatement)(nextElement) && nextElement.range.start.line === element.range.start.line) {
                 //add a newline between statements
             }
             else {
@@ -600,14 +630,7 @@ class AALiteralExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            for (let i = 0; i < this.elements.length; i++) {
-                if (reflection_1.isCommentStatement(this.elements[i])) {
-                    visitors_1.walk(this.elements, i, visitor, options, this);
-                }
-                else {
-                    visitors_1.walk(this.elements, i, visitor, options, this);
-                }
-            }
+            (0, visitors_1.walkArray)(this.elements, visitor, options, this);
         }
     }
 }
@@ -617,7 +640,7 @@ class UnaryExpression extends Expression {
         super();
         this.operator = operator;
         this.right = right;
-        this.range = util_1.default.createRangeFromPositions(this.operator.range.start, this.right.range.end);
+        this.range = util_1.default.createBoundingRange(this.operator, this.right);
     }
     transpile(state) {
         return [
@@ -628,7 +651,7 @@ class UnaryExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'right', visitor, options);
+            (0, visitors_1.walk)(this, 'right', visitor, options);
         }
     }
 }
@@ -686,28 +709,30 @@ class SourceLiteralExpression extends Expression {
     transpile(state) {
         let text;
         switch (this.token.kind) {
-            case lexer_1.TokenKind.SourceFilePathLiteral:
-                text = `"${fileUrl(state.srcPath)}"`;
+            case TokenKind_1.TokenKind.SourceFilePathLiteral:
+                const pathUrl = fileUrl(state.srcPath);
+                text = `"${pathUrl.substring(0, 4)}" + "${pathUrl.substring(4)}"`;
                 break;
-            case lexer_1.TokenKind.SourceLineNumLiteral:
+            case TokenKind_1.TokenKind.SourceLineNumLiteral:
                 text = `${this.token.range.start.line + 1}`;
                 break;
-            case lexer_1.TokenKind.FunctionNameLiteral:
+            case TokenKind_1.TokenKind.FunctionNameLiteral:
                 text = `"${this.getFunctionName(state, Parser_1.ParseMode.BrightScript)}"`;
                 break;
-            case lexer_1.TokenKind.SourceFunctionNameLiteral:
+            case TokenKind_1.TokenKind.SourceFunctionNameLiteral:
                 text = `"${this.getFunctionName(state, Parser_1.ParseMode.BrighterScript)}"`;
                 break;
-            case lexer_1.TokenKind.SourceLocationLiteral:
-                text = `"${fileUrl(state.srcPath)}:${this.token.range.start.line + 1}"`;
+            case TokenKind_1.TokenKind.SourceLocationLiteral:
+                const locationUrl = fileUrl(state.srcPath);
+                text = `"${locationUrl.substring(0, 4)}" + "${locationUrl.substring(4)}:${this.token.range.start.line + 1}"`;
                 break;
-            case lexer_1.TokenKind.PkgPathLiteral:
+            case TokenKind_1.TokenKind.PkgPathLiteral:
                 text = `"${state.file.pkgPath.replace(/\.bs$/i, '.brs')}"`;
                 break;
-            case lexer_1.TokenKind.PkgLocationLiteral:
+            case TokenKind_1.TokenKind.PkgLocationLiteral:
                 text = `"${state.file.pkgPath.replace(/\.bs$/i, '.brs')}:" + str(LINE_NUM)`;
                 break;
-            case lexer_1.TokenKind.LineNumLiteral:
+            case TokenKind_1.TokenKind.LineNumLiteral:
             default:
                 //use the original text (because it looks like a variable)
                 text = this.token.text;
@@ -732,7 +757,7 @@ class NewExpression extends Expression {
         super();
         this.newKeyword = newKeyword;
         this.call = call;
-        this.range = util_1.default.createRangeFromPositions(this.newKeyword.range.start, this.call.range.end);
+        this.range = util_1.default.createBoundingRange(this.newKeyword, this.call);
     }
     /**
      * The name of the class to initialize (with optional namespace prefixed)
@@ -754,14 +779,14 @@ class NewExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'call', visitor, options);
+            (0, visitors_1.walk)(this, 'call', visitor, options);
         }
     }
 }
 exports.NewExpression = NewExpression;
 class CallfuncExpression extends Expression {
     constructor(callee, operator, methodName, openingParen, args, closingParen) {
-        var _a, _b, _c;
+        var _a;
         super();
         this.callee = callee;
         this.operator = operator;
@@ -769,7 +794,7 @@ class CallfuncExpression extends Expression {
         this.openingParen = openingParen;
         this.args = args;
         this.closingParen = closingParen;
-        this.range = util_1.default.createRangeFromPositions(callee.range.start, ((_c = (_b = (_a = closingParen !== null && closingParen !== void 0 ? closingParen : args[args.length - 1]) !== null && _a !== void 0 ? _a : openingParen) !== null && _b !== void 0 ? _b : methodName) !== null && _c !== void 0 ? _c : operator).range.end);
+        this.range = util_1.default.createBoundingRange(this.callee, this.operator, this.methodName, this.openingParen, ...((_a = this.args) !== null && _a !== void 0 ? _a : []), this.closingParen);
     }
     transpile(state) {
         let result = [];
@@ -796,10 +821,8 @@ class CallfuncExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'callee', visitor, options);
-            for (let i = 0; i < this.args.length; i++) {
-                visitors_1.walk(this.args, i, visitor, options, this);
-            }
+            (0, visitors_1.walk)(this, 'callee', visitor, options);
+            (0, visitors_1.walkArray)(this.args, visitor, options, this);
         }
     }
 }
@@ -810,9 +833,10 @@ exports.CallfuncExpression = CallfuncExpression;
  */
 class TemplateStringQuasiExpression extends Expression {
     constructor(expressions) {
+        var _a;
         super();
         this.expressions = expressions;
-        this.range = util_1.default.createRangeFromPositions(this.expressions[0].range.start, this.expressions[this.expressions.length - 1].range.end);
+        this.range = util_1.default.createBoundingRange(...((_a = this.expressions) !== null && _a !== void 0 ? _a : []));
     }
     transpile(state, skipEmptyStrings = true) {
         let result = [];
@@ -830,21 +854,21 @@ class TemplateStringQuasiExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            for (let i = 0; i < this.expressions.length; i++) {
-                visitors_1.walk(this.expressions, i, visitor, options, this);
-            }
+            (0, visitors_1.walkArray)(this.expressions, visitor, options, this);
         }
     }
 }
 exports.TemplateStringQuasiExpression = TemplateStringQuasiExpression;
 class TemplateStringExpression extends Expression {
     constructor(openingBacktick, quasis, expressions, closingBacktick) {
+        var _a;
         super();
         this.openingBacktick = openingBacktick;
         this.quasis = quasis;
         this.expressions = expressions;
         this.closingBacktick = closingBacktick;
-        this.range = util_1.default.createRangeFromPositions(quasis[0].range.start, quasis[quasis.length - 1].range.end);
+        //the expression always starts and ends with a quasi, so we don't need to consider the expression locations
+        this.range = util_1.default.createBoundingRange(this.openingBacktick, ...((_a = this.quasis) !== null && _a !== void 0 ? _a : []), this.closingBacktick);
     }
     transpile(state) {
         if (this.quasis.length === 1 && this.expressions.length === 0) {
@@ -868,8 +892,8 @@ class TemplateStringExpression extends Expression {
             add(...quasi.transpile(state));
             if (expression) {
                 //skip the toString wrapper around certain expressions
-                if (reflection_1.isEscapedCharCodeLiteralExpression(expression) ||
-                    (reflection_1.isLiteralExpression(expression) && reflection_1.isStringType(expression.type))) {
+                if ((0, reflection_1.isEscapedCharCodeLiteralExpression)(expression) ||
+                    ((0, reflection_1.isLiteralExpression)(expression) && (0, reflection_1.isStringType)(expression.type))) {
                     add(...expression.transpile(state));
                     //wrap all other expressions with a bslib_toString call to prevent runtime type mismatch errors
                 }
@@ -884,10 +908,10 @@ class TemplateStringExpression extends Expression {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
             //walk the quasis and expressions in left-to-right order
             for (let i = 0; i < this.quasis.length; i++) {
-                visitors_1.walk(this.quasis, i, visitor, options, this);
+                (0, visitors_1.walk)(this.quasis, i, visitor, options, this);
                 //this skips the final loop iteration since we'll always have one more quasi than expression
                 if (this.expressions[i]) {
-                    visitors_1.walk(this.expressions, i, visitor, options, this);
+                    (0, visitors_1.walk)(this.expressions, i, visitor, options, this);
                 }
             }
         }
@@ -896,13 +920,15 @@ class TemplateStringExpression extends Expression {
 exports.TemplateStringExpression = TemplateStringExpression;
 class TaggedTemplateStringExpression extends Expression {
     constructor(tagName, openingBacktick, quasis, expressions, closingBacktick) {
+        var _a;
         super();
         this.tagName = tagName;
         this.openingBacktick = openingBacktick;
         this.quasis = quasis;
         this.expressions = expressions;
         this.closingBacktick = closingBacktick;
-        this.range = util_1.default.createRangeFromPositions(quasis[0].range.start, quasis[quasis.length - 1].range.end);
+        //the expression always starts and ends with a quasi, so we don't need to consider the expression locations
+        this.range = util_1.default.createBoundingRange(this.tagName, this.openingBacktick, ...((_a = this.quasis) !== null && _a !== void 0 ? _a : []), this.closingBacktick);
     }
     transpile(state) {
         let result = [];
@@ -932,10 +958,10 @@ class TaggedTemplateStringExpression extends Expression {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
             //walk the quasis and expressions in left-to-right order
             for (let i = 0; i < this.quasis.length; i++) {
-                visitors_1.walk(this.quasis, i, visitor, options, this);
+                (0, visitors_1.walk)(this.quasis, i, visitor, options, this);
                 //this skips the final loop iteration since we'll always have one more quasi than expression
                 if (this.expressions[i]) {
-                    visitors_1.walk(this.expressions, i, visitor, options, this);
+                    (0, visitors_1.walk)(this.expressions, i, visitor, options, this);
                 }
             }
         }
@@ -948,7 +974,15 @@ class AnnotationExpression extends Expression {
         this.atToken = atToken;
         this.nameToken = nameToken;
         this.name = nameToken.text;
-        this.range = util_1.default.createRangeFromPositions(atToken.range.start, nameToken.range.end);
+    }
+    get range() {
+        return this.cacheRange();
+    }
+    cacheRange() {
+        if (!this._range) {
+            this._range = util_1.default.createBoundingRange(this.atToken, this.nameToken, this.call);
+        }
+        return this._range;
     }
     /**
      * Convert annotation arguments to JavaScript types
@@ -978,14 +1012,13 @@ class AnnotationExpression extends Expression {
 exports.AnnotationExpression = AnnotationExpression;
 class TernaryExpression extends Expression {
     constructor(test, questionMarkToken, consequent, colonToken, alternate) {
-        var _a, _b, _c;
         super();
         this.test = test;
         this.questionMarkToken = questionMarkToken;
         this.consequent = consequent;
         this.colonToken = colonToken;
         this.alternate = alternate;
-        this.range = util_1.default.createRangeFromPositions(test.range.start, ((_c = (_b = (_a = alternate !== null && alternate !== void 0 ? alternate : colonToken) !== null && _a !== void 0 ? _a : consequent) !== null && _b !== void 0 ? _b : questionMarkToken) !== null && _c !== void 0 ? _c : test).range.end);
+        this.range = util_1.default.createBoundingRange(this.test, this.questionMarkToken, this.consequent, this.colonToken, this.alternate);
     }
     transpile(state) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
@@ -1014,21 +1047,20 @@ class TernaryExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'test', visitor, options);
-            visitors_1.walk(this, 'consequent', visitor, options);
-            visitors_1.walk(this, 'alternate', visitor, options);
+            (0, visitors_1.walk)(this, 'test', visitor, options);
+            (0, visitors_1.walk)(this, 'consequent', visitor, options);
+            (0, visitors_1.walk)(this, 'alternate', visitor, options);
         }
     }
 }
 exports.TernaryExpression = TernaryExpression;
 class NullCoalescingExpression extends Expression {
     constructor(consequent, questionQuestionToken, alternate) {
-        var _a;
         super();
         this.consequent = consequent;
         this.questionQuestionToken = questionQuestionToken;
         this.alternate = alternate;
-        this.range = util_1.default.createRangeFromPositions(consequent.range.start, ((_a = alternate !== null && alternate !== void 0 ? alternate : questionQuestionToken) !== null && _a !== void 0 ? _a : consequent).range.end);
+        this.range = util_1.default.createBoundingRange(this.consequent, this.questionQuestionToken, this.alternate);
     }
     transpile(state) {
         let result = [];
@@ -1039,7 +1071,7 @@ class NullCoalescingExpression extends Expression {
         let hasMutatingExpression = [
             ...consequentInfo.expressions,
             ...alternateInfo.expressions
-        ].find(e => reflection_1.isCallExpression(e) || reflection_1.isCallfuncExpression(e) || reflection_1.isDottedGetExpression(e));
+        ].find(e => (0, reflection_1.isCallExpression)(e) || (0, reflection_1.isCallfuncExpression)(e) || (0, reflection_1.isDottedGetExpression)(e));
         if (hasMutatingExpression) {
             result.push(`(function(`, 
             //write all the scope variables as parameters.
@@ -1058,37 +1090,175 @@ class NullCoalescingExpression extends Expression {
     }
     walk(visitor, options) {
         if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'consequent', visitor, options);
-            visitors_1.walk(this, 'alternate', visitor, options);
+            (0, visitors_1.walk)(this, 'consequent', visitor, options);
+            (0, visitors_1.walk)(this, 'alternate', visitor, options);
         }
     }
 }
 exports.NullCoalescingExpression = NullCoalescingExpression;
+class RegexLiteralExpression extends Expression {
+    constructor(tokens) {
+        super();
+        this.tokens = tokens;
+        this.range = this.tokens.regexLiteral.range;
+    }
+    transpile(state) {
+        var _a, _b;
+        let text = (_b = (_a = this.tokens.regexLiteral) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : '';
+        let flags = '';
+        //get any flags from the end
+        const flagMatch = /\/([a-z]+)$/i.exec(text);
+        if (flagMatch) {
+            text = text.substring(0, flagMatch.index + 1);
+            flags = flagMatch[1];
+        }
+        let pattern = text
+            //remove leading and trailing slashes
+            .substring(1, text.length - 1)
+            //escape quotemarks
+            .split('"').join('" + chr(34) + "');
+        return [
+            state.sourceNode(this.tokens.regexLiteral, [
+                'CreateObject("roRegex", ',
+                `"${pattern}", `,
+                `"${flags}"`,
+                ')'
+            ])
+        ];
+    }
+    walk(visitor, options) {
+        //nothing to walk
+    }
+}
+exports.RegexLiteralExpression = RegexLiteralExpression;
+class TypeExpression extends Expression {
+    constructor(tokens, namespaceName) {
+        super();
+        this.tokens = tokens;
+        this.namespaceName = namespaceName;
+        this.range = util_1.default.createBoundingRange(this.tokens.type);
+    }
+    /**
+     * The this TypeExpression refers to
+     */
+    get type() {
+        if (this._type) {
+            return this._type;
+        }
+        this._type = this.getType(Parser_1.ParseMode.BrighterScript);
+        return this._type;
+    }
+    /**
+     * Derive a BscType from the type token
+     * Can deal with multiple brackets to make multidimensional arrays, eg. float[][]
+     * Defaults to `DynamicType`
+     */
+    getType(parseMode = Parser_1.ParseMode.BrighterScript) {
+        let exprType = this.tokens.type
+            ? util_1.default.tokenToBscType(this.tokens.type, parseMode === Parser_1.ParseMode.BrighterScript, this.namespaceName)
+            : new DynamicType_1.DynamicType();
+        return exprType;
+    }
+    /**
+     * Is this a valid, (eg. known) type?
+     */
+    isValidType(parseMode = Parser_1.ParseMode.BrighterScript) {
+        return !!util_1.default.tokenToBscType(this.tokens.type, parseMode === Parser_1.ParseMode.BrighterScript, this.namespaceName);
+    }
+    /**
+     * Gives a human readable string that says the type
+     * @returns text to display to show the type
+     */
+    getText() {
+        let result = this.tokens.type.text;
+        return result;
+    }
+    transpile(state) {
+        let result = [];
+        //type declaration
+        result.push(state.sourceNode({ range: this.range }, this.type.toTypeString(state.typeContext)));
+        return result;
+    }
+    walk(visitor, options) {
+        //nothing to walk
+    }
+}
+exports.TypeExpression = TypeExpression;
+class ArrayTypeExpression extends TypeExpression {
+    constructor(innerTypes, // this is an array so that in the future when we support union types
+    bracketTokens, namespaceName) {
+        super({}, namespaceName);
+        this.innerTypes = innerTypes;
+        this.bracketTokens = bracketTokens;
+        this.namespaceName = namespaceName;
+        this.range = util_1.default.createBoundingRange(this.bracketTokens.leftBracket, this.bracketTokens.rightBracket, ...this.innerTypes);
+    }
+    /*
+     * TODO - Support union types
+    */
+    get defaultTypeExpression() {
+        return this.innerTypes[0];
+    }
+    /**
+     * Derive a BscType from the type token
+     * Returns an array type with the inner types based on the inner type expressions
+     */
+    getType(parseMode = Parser_1.ParseMode.BrighterScript) {
+        const innerBscTypes = this.innerTypes.map(inner => inner.getType(parseMode));
+        return new ArrayType_1.ArrayType(...innerBscTypes);
+    }
+    /**
+     * Is this a valid, (eg. known) type?
+     */
+    isValidType(parseMode = Parser_1.ParseMode.BrighterScript) {
+        if (parseMode === Parser_1.ParseMode.BrighterScript) {
+            return this.innerTypes.reduce((validSoFar, innerType) => {
+                return validSoFar && innerType.isValidType(parseMode);
+            }, true);
+        }
+        return false;
+    }
+    /**
+     * Gives a human readable string that says the type
+     * @returns text to display to show the type
+     */
+    getText() {
+        return this.defaultTypeExpression.getText() + '[]';
+    }
+    walk(visitor, options) {
+        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
+            for (let i = 0; i < this.innerTypes.length; i++) {
+                (0, visitors_1.walk)(this.innerTypes, i, visitor, options, this);
+            }
+        }
+    }
+}
+exports.ArrayTypeExpression = ArrayTypeExpression;
 function expressionToValue(expr, strict) {
     if (!expr) {
         return null;
     }
-    if (reflection_1.isUnaryExpression(expr) && reflection_1.isLiteralNumber(expr.right)) {
+    if ((0, reflection_1.isUnaryExpression)(expr) && (0, reflection_1.isLiteralNumber)(expr.right)) {
         return numberExpressionToValue(expr.right, expr.operator.text);
     }
-    if (reflection_1.isLiteralString(expr)) {
+    if ((0, reflection_1.isLiteralString)(expr)) {
         //remove leading and trailing quotes
         return expr.token.text.replace(/^"/, '').replace(/"$/, '');
     }
-    if (reflection_1.isLiteralNumber(expr)) {
+    if ((0, reflection_1.isLiteralNumber)(expr)) {
         return numberExpressionToValue(expr);
     }
-    if (reflection_1.isLiteralBoolean(expr)) {
+    if ((0, reflection_1.isLiteralBoolean)(expr)) {
         return expr.token.text.toLowerCase() === 'true';
     }
-    if (reflection_1.isArrayLiteralExpression(expr)) {
+    if ((0, reflection_1.isArrayLiteralExpression)(expr)) {
         return expr.elements
-            .filter(e => !reflection_1.isCommentStatement(e))
+            .filter(e => !(0, reflection_1.isCommentStatement)(e))
             .map(e => expressionToValue(e, strict));
     }
-    if (reflection_1.isAALiteralExpression(expr)) {
+    if ((0, reflection_1.isAALiteralExpression)(expr)) {
         return expr.elements.reduce((acc, e) => {
-            if (!reflection_1.isCommentStatement(e)) {
+            if (!(0, reflection_1.isCommentStatement)(e)) {
                 acc[e.keyToken.text] = expressionToValue(e.value, strict);
             }
             return acc;
@@ -1097,7 +1267,7 @@ function expressionToValue(expr, strict) {
     return strict ? null : expr;
 }
 function numberExpressionToValue(expr, operator = '') {
-    if (reflection_1.isIntegerType(expr.type) || reflection_1.isLongIntegerType(expr.type)) {
+    if ((0, reflection_1.isIntegerType)(expr.type) || (0, reflection_1.isLongIntegerType)(expr.type)) {
         return parseInt(operator + expr.token.text);
     }
     else {