brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/parser/Expression.js

@@ -1,75 +1,113 @@
 "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.InlineInterfaceMemberExpression = exports.InlineInterfaceExpression = exports.TypedArrayExpression = exports.TypecastExpression = 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.PrintSeparatorExpression = exports.LiteralExpression = exports.GroupingExpression = exports.IndexedGetExpression = exports.XmlAttributeGetExpression = exports.DottedGetExpression = exports.FunctionParameterExpression = exports.FunctionExpression = exports.CallExpression = exports.BinaryExpression = void 0;
+const TokenKind_1 = require("../lexer/TokenKind");
 const util_1 = require("../util");
 const Parser_1 = require("./Parser");
 const fileUrl = require("file-url");
 const visitors_1 = require("../astUtils/visitors");
+const visitors_2 = require("../astUtils/visitors");
 const reflection_1 = require("../astUtils/reflection");
+const interfaces_1 = require("../interfaces");
 const VoidType_1 = require("../types/VoidType");
 const DynamicType_1 = require("../types/DynamicType");
+const AstNode_1 = require("./AstNode");
 const SymbolTable_1 = require("../SymbolTable");
+const source_map_1 = require("source-map");
+const StringType_1 = require("../types/StringType");
+const ReferenceType_1 = require("../types/ReferenceType");
+const UnionType_1 = require("../types/UnionType");
+const ArrayType_1 = require("../types/ArrayType");
+const AssociativeArrayType_1 = require("../types/AssociativeArrayType");
+const TypedFunctionType_1 = require("../types/TypedFunctionType");
+const InvalidType_1 = require("../types/InvalidType");
+const UninitializedType_1 = require("../types/UninitializedType");
 const FunctionType_1 = require("../types/FunctionType");
-/** A BrightScript expression */
-class Expression {
-    constructor() {
-        /**
-         * When being considered by the walk visitor, this describes what type of element the current class is.
-         */
-        this.visitMode = visitors_1.InternalWalkMode.visitExpressions;
-    }
-}
-exports.Expression = Expression;
-class BinaryExpression extends Expression {
-    constructor(left, operator, right) {
+const BrightScriptDocParser_1 = require("./BrightScriptDocParser");
+const InlineInterfaceType_1 = require("../types/InlineInterfaceType");
+const IntersectionType_1 = require("../types/IntersectionType");
+class BinaryExpression extends AstNode_1.Expression {
+    constructor(options) {
         super();
-        this.left = left;
-        this.operator = operator;
-        this.right = right;
-        this.range = util_1.default.createRangeFromPositions(this.left.range.start, this.right.range.end);
+        this.kind = AstNode_1.AstNodeKind.BinaryExpression;
+        this.tokens = {
+            operator: options.operator
+        };
+        this.left = options.left;
+        this.right = options.right;
+        this.location = util_1.default.createBoundingLocation(this.left, this.tokens.operator, this.right);
     }
     transpile(state) {
         return [
             state.sourceNode(this.left, this.left.transpile(state)),
             ' ',
-            state.transpileToken(this.operator),
+            state.transpileToken(this.tokens.operator),
             ' ',
             state.sourceNode(this.right, this.right.transpile(state))
         ];
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'left', visitor, options);
-            visitors_1.walk(this, 'right', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'left', visitor, options);
+            (0, visitors_2.walk)(this, 'right', visitor, options);
         }
     }
+    getType(options) {
+        var _a;
+        const operatorKind = this.tokens.operator.kind;
+        if (options.flags & 2 /* SymbolTypeFlag.typetime */) {
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+            switch (operatorKind) {
+                case TokenKind_1.TokenKind.Or:
+                    return new UnionType_1.UnionType([this.left.getType(options), this.right.getType(options)]);
+                case TokenKind_1.TokenKind.And:
+                    return new IntersectionType_1.IntersectionType([this.left.getType(options), this.right.getType(options)]);
+                //TODO: Intersection Types?, eg. case TokenKind.And:
+            }
+        }
+        else if (options.flags & 1 /* SymbolTypeFlag.runtime */) {
+            return (_a = util_1.default.binaryOperatorResultType(this.left.getType(options), this.tokens.operator, this.right.getType(options))) !== null && _a !== void 0 ? _a : DynamicType_1.DynamicType.instance;
+        }
+        return DynamicType_1.DynamicType.instance;
+    }
+    get leadingTrivia() {
+        return this.left.leadingTrivia;
+    }
+    clone() {
+        var _a, _b;
+        return this.finalizeClone(new BinaryExpression({
+            left: (_a = this.left) === null || _a === void 0 ? void 0 : _a.clone(),
+            operator: util_1.default.cloneToken(this.tokens.operator),
+            right: (_b = this.right) === null || _b === void 0 ? void 0 : _b.clone()
+        }), ['left', 'right']);
+    }
 }
 exports.BinaryExpression = BinaryExpression;
-class CallExpression extends Expression {
-    constructor(callee, 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.
-     */
-    namespaceName) {
+class CallExpression extends AstNode_1.Expression {
+    constructor(options) {
+        var _a, _b;
         super();
-        this.callee = callee;
-        this.openingParen = openingParen;
-        this.closingParen = closingParen;
-        this.args = args;
-        this.namespaceName = namespaceName;
-        this.range = util_1.default.createRangeFromPositions(this.callee.range.start, this.closingParen.range.end);
+        this.kind = AstNode_1.AstNodeKind.CallExpression;
+        this.tokens = {
+            openingParen: options.openingParen,
+            closingParen: options.closingParen
+        };
+        this.callee = options.callee;
+        this.args = (_a = options.args) !== null && _a !== void 0 ? _a : [];
+        this.location = util_1.default.createBoundingLocation(this.callee, this.tokens.openingParen, ...(_b = this.args) !== null && _b !== void 0 ? _b : [], this.tokens.closingParen);
     }
     transpile(state, nameOverride) {
         let result = [];
         //transpile the name
         if (nameOverride) {
-            result.push(state.sourceNode(this.callee, nameOverride));
+            result.push(
+            //transpile leading comments since we're bypassing callee.transpile (which would normally do this)
+            ...state.transpileLeadingCommentsForAstNode(this), state.sourceNode(this.callee, nameOverride));
         }
         else {
             result.push(...this.callee.transpile(state));
         }
-        result.push(state.transpileToken(this.openingParen));
+        result.push(state.transpileToken(this.tokens.openingParen, '('));
         for (let i = 0; i < this.args.length; i++) {
             //add comma between args
             if (i > 0) {
@@ -78,80 +116,115 @@ class CallExpression extends Expression {
             let arg = this.args[i];
             result.push(...arg.transpile(state));
         }
-        result.push(state.transpileToken(this.closingParen));
+        result.push(state.transpileToken(this.tokens.closingParen, ')'));
         return result;
     }
     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);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'callee', visitor, options);
+            (0, visitors_2.walkArray)(this.args, visitor, options, this);
+        }
+    }
+    getType(options) {
+        var _a, _b, _c;
+        const calleeType = this.callee.getType(options);
+        if (options.ignoreCall) {
+            return calleeType;
+        }
+        if ((0, reflection_1.isNewExpression)(this.parent)) {
+            return calleeType;
+        }
+        const specialCaseReturnType = util_1.default.getSpecialCaseCallExpressionReturnType(this, options);
+        if (specialCaseReturnType) {
+            return specialCaseReturnType;
+        }
+        if ((0, reflection_1.isCallableType)(calleeType) && (!(0, reflection_1.isReferenceType)(calleeType.returnType) || ((_a = calleeType.returnType) === null || _a === void 0 ? void 0 : _a.isResolvable()))) {
+            if ((0, reflection_1.isVoidType)(calleeType.returnType)) {
+                if ((_b = options.data) === null || _b === void 0 ? void 0 : _b.isBuiltIn) {
+                    // built in functions that return `as void` will not initialize the result
+                    return UninitializedType_1.UninitializedType.instance;
+                }
+                // non-built in functions with return type`as void` actually return `invalid`
+                return InvalidType_1.InvalidType.instance;
             }
+            return calleeType.returnType;
+        }
+        if (util_1.default.isUnionOfFunctions(calleeType, true)) {
+            return util_1.default.getReturnTypeOfUnionOfFunctions(calleeType);
         }
+        if (!(0, reflection_1.isReferenceType)(calleeType) && ((_c = calleeType === null || calleeType === void 0 ? void 0 : calleeType.returnType) === null || _c === void 0 ? void 0 : _c.isResolvable())) {
+            return calleeType.returnType;
+        }
+        return new ReferenceType_1.TypePropertyReferenceType(calleeType, 'returnType');
+    }
+    get leadingTrivia() {
+        return this.callee.leadingTrivia;
+    }
+    clone() {
+        var _a, _b;
+        return this.finalizeClone(new CallExpression({
+            callee: (_a = this.callee) === null || _a === void 0 ? void 0 : _a.clone(),
+            openingParen: util_1.default.cloneToken(this.tokens.openingParen),
+            closingParen: util_1.default.cloneToken(this.tokens.closingParen),
+            args: (_b = this.args) === null || _b === void 0 ? void 0 : _b.map(e => e === null || e === void 0 ? void 0 : e.clone())
+        }), ['callee', 'args']);
     }
 }
 exports.CallExpression = CallExpression;
-CallExpression.MaximumArguments = 32;
-class FunctionExpression extends Expression {
-    constructor(parameters, body, functionType, end, leftParen, rightParen, asToken, returnTypeToken, 
-    /**
-     * If this function is enclosed within another function, this will reference that parent function
-     */
-    parentFunction, namespaceName, parentSymbolTable) {
+/**
+ * Number of parameters that can be defined on a function
+ *
+ * Prior to Roku OS 11.5, this was 32
+ * As of Roku OS 11.5, this is 63
+ */
+CallExpression.MaximumArguments = 63;
+class FunctionExpression extends AstNode_1.Expression {
+    constructor(options) {
+        var _a;
         super();
-        this.parameters = parameters;
-        this.body = body;
-        this.functionType = functionType;
-        this.end = end;
-        this.leftParen = leftParen;
-        this.rightParen = rightParen;
-        this.asToken = asToken;
-        this.returnTypeToken = returnTypeToken;
-        this.parentFunction = parentFunction;
-        this.namespaceName = namespaceName;
-        this.parentSymbolTable = parentSymbolTable;
-        this.labelStatements = [];
-        /**
-         * The list of function calls that are declared within this function scope. This excludes CallExpressions
-         * declared in child functions
-         */
-        this.callExpressions = [];
-        /**
-         * A list of all child functions declared directly within this function
-         */
-        this.childFunctionExpressions = [];
-        if (this.returnTypeToken) {
-            this.returnType = util_1.default.tokenToBscType(this.returnTypeToken);
-        }
-        else if (this.functionType.text.toLowerCase() === 'sub') {
-            this.returnType = new VoidType_1.VoidType();
-        }
-        else {
-            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.kind = AstNode_1.AstNodeKind.FunctionExpression;
+        this.tokens = {
+            functionType: options.functionType,
+            leftParen: options.leftParen,
+            rightParen: options.rightParen,
+            as: options.as,
+            endFunctionType: options.endFunctionType
+        };
+        this.parameters = (_a = options.parameters) !== null && _a !== void 0 ? _a : [];
+        this.body = options.body;
+        this.returnTypeExpression = options.returnTypeExpression;
+        if (this.body) {
+            this.body.parent = this;
         }
+        this.symbolTable = new SymbolTable_1.SymbolTable('FunctionExpression', () => { var _a; return (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getSymbolTable(); });
+    }
+    get leadingTrivia() {
+        var _a;
+        return (_a = this.tokens.functionType) === null || _a === void 0 ? void 0 : _a.leadingTrivia;
+    }
+    get endTrivia() {
+        var _a;
+        return (_a = this.tokens.endFunctionType) === null || _a === void 0 ? void 0 : _a.leadingTrivia;
     }
     /**
      * 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'
      */
-    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);
+    get location() {
+        var _a;
+        return util_1.default.createBoundingLocation(this.tokens.functionType, this.tokens.leftParen, ...(_a = this.parameters) !== null && _a !== void 0 ? _a : [], this.tokens.rightParen, this.tokens.as, this.returnTypeExpression, this.tokens.endFunctionType);
     }
     transpile(state, name, includeBody = true) {
+        var _a, _b, _c;
         let results = [];
         //'function'|'sub'
-        results.push(state.transpileToken(this.functionType));
+        results.push(state.transpileToken(this.tokens.functionType, 'function', false, state.skipLeadingComments));
         //functionName?
         if (name) {
             results.push(' ', state.transpileToken(name));
         }
         //leftParen
-        results.push(state.transpileToken(this.leftParen));
+        results.push(state.transpileToken(this.tokens.leftParen, '('));
         //parameters
         for (let i = 0; i < this.parameters.length; i++) {
             let param = this.parameters[i];
@@ -163,71 +236,189 @@ class FunctionExpression extends Expression {
             results.push(param.transpile(state));
         }
         //right paren
-        results.push(state.transpileToken(this.rightParen));
+        results.push(state.transpileToken(this.tokens.rightParen, ')'));
         //as [Type]
-        if (this.asToken) {
+        if (this.tokens.as && this.returnTypeExpression && (this.requiresReturnType || !state.options.removeParameterTypes)) {
             results.push(' ', 
             //as
-            state.transpileToken(this.asToken), ' ', 
+            state.transpileToken(this.tokens.as, 'as'), ' ', 
             //return type
-            state.sourceNode(this.returnTypeToken, this.returnType.toTypeString()));
+            ...this.returnTypeExpression.transpile(state));
         }
+        let hasBody = false;
         if (includeBody) {
             state.lineage.unshift(this);
             let body = this.body.transpile(state);
+            hasBody = body.length > 0;
             state.lineage.shift();
             results.push(...body);
         }
-        results.push('\n');
-        //'end sub'|'end function'
-        results.push(state.indent(), state.transpileToken(this.end));
+        const lastLocatable = hasBody ? this.body : (_b = (_a = this.returnTypeExpression) !== null && _a !== void 0 ? _a : this.tokens.leftParen) !== null && _b !== void 0 ? _b : this.tokens.functionType;
+        results.push(...state.transpileEndBlockToken(lastLocatable, this.tokens.endFunctionType, `end ${(_c = this.tokens.functionType) !== null && _c !== void 0 ? _c : 'function'}`));
         return results;
     }
-    getTypedef(state, name) {
-        return this.transpile(state, name, false);
+    getTypedef(state) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        let results = [
+            new source_map_1.SourceNode(1, 0, null, [
+                //'function'|'sub'
+                (_b = (_a = this.tokens.functionType) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : 'function',
+                //functionName?
+                ...((0, reflection_1.isFunctionStatement)(this.parent) || (0, reflection_1.isMethodStatement)(this.parent) ? [' ', (_d = (_c = this.parent.tokens.name) === null || _c === void 0 ? void 0 : _c.text) !== null && _d !== void 0 ? _d : ''] : []),
+                //leftParen
+                '(',
+                //parameters
+                ...((_f = (_e = this.parameters) === null || _e === void 0 ? void 0 : _e.map((param, i) => ([
+                    //separating comma
+                    i > 0 ? ', ' : '',
+                    ...param.getTypedef(state)
+                ]))) !== null && _f !== void 0 ? _f : []),
+                //right paren
+                ')',
+                //as <ReturnType>
+                ...(this.returnTypeExpression ? [
+                    ' ',
+                    (_h = (_g = this.tokens.as) === null || _g === void 0 ? void 0 : _g.text) !== null && _h !== void 0 ? _h : 'as',
+                    ' ',
+                    ...this.returnTypeExpression.getTypedef(state)
+                ] : []),
+                '\n',
+                state.indent(),
+                //'end sub'|'end function'
+                (_k = (_j = this.tokens.endFunctionType) === null || _j === void 0 ? void 0 : _j.text) !== null && _k !== void 0 ? _k : `end ${(_l = this.tokens.functionType) !== null && _l !== void 0 ? _l : 'function'}`
+            ])
+        ];
+        return results;
     }
     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);
-            }
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walkArray)(this.parameters, visitor, options, this);
+            (0, visitors_2.walk)(this, 'returnTypeExpression', visitor, options);
             //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);
+            if (options.walkMode & visitors_2.InternalWalkMode.recurseChildFunctions) {
+                (0, visitors_2.walk)(this, 'body', visitor, options);
             }
         }
     }
-    getFunctionType() {
-        let functionType = new FunctionType_1.FunctionType(this.returnType);
-        functionType.isSub = this.functionType.text === 'sub';
+    getType(options) {
+        var _a, _b, _c, _d;
+        //if there's a defined return type, use that
+        let returnType;
+        const docs = BrightScriptDocParser_1.brsDocParser.parseNode(this.findAncestor(reflection_1.isFunctionStatement));
+        returnType = util_1.default.chooseTypeFromCodeOrDocComment((_a = this.returnTypeExpression) === null || _a === void 0 ? void 0 : _a.getType(Object.assign(Object.assign({}, options), { typeChain: undefined })), docs.getReturnBscType(Object.assign(Object.assign({}, options), { tableProvider: () => this.getSymbolTable() })), options);
+        const isSub = ((_b = this.tokens.functionType) === null || _b === void 0 ? void 0 : _b.kind) === TokenKind_1.TokenKind.Sub;
+        //if we don't have a return type and this is a sub, set the return type to `void`. else use `dynamic`
+        if (!returnType) {
+            returnType = isSub ? VoidType_1.VoidType.instance : DynamicType_1.DynamicType.instance;
+        }
+        const resultType = new TypedFunctionType_1.TypedFunctionType(returnType);
+        resultType.isSub = isSub;
         for (let param of this.parameters) {
-            functionType.addParameter(param.name.text, param.type, param.isOptional);
+            resultType.addParameter(param.tokens.name.text, param.getType(Object.assign(Object.assign({}, options), { typeChain: undefined })), !!param.defaultValue);
+        }
+        // Figure out this function's name if we can
+        let funcName = '';
+        if ((0, reflection_1.isMethodStatement)(this.parent) || (0, reflection_1.isInterfaceMethodStatement)(this.parent)) {
+            funcName = this.parent.getName(Parser_1.ParseMode.BrighterScript);
+            if (options.typeChain) {
+                // Get the typechain info from the parent class
+                (_c = this.parent.parent) === null || _c === void 0 ? void 0 : _c.getType(options);
+            }
+        }
+        else if ((0, reflection_1.isFunctionStatement)(this.parent)) {
+            funcName = this.parent.getName(Parser_1.ParseMode.BrighterScript);
+        }
+        if (funcName) {
+            resultType.setName(funcName);
         }
-        return functionType;
+        (_d = options.typeChain) === null || _d === void 0 ? void 0 : _d.push(new interfaces_1.TypeChainEntry({ name: funcName, type: resultType, data: options.data, astNode: this }));
+        return resultType;
+    }
+    get requiresReturnType() {
+        /**
+         * RokuOS methods can be written several different ways:
+         * 1. Function() : return withValue
+         * 2. Function() as type : return withValue
+         * 3. Function() as void : return
+         *
+         * 4. Sub() : return
+         * 5. Sub () as void : return
+         * 6. Sub() as type : return withValue
+         *
+         * Formats (1), (2), and (6) throw a compile error if there IS NOT a return value in the function body.
+         * Formats (3), (4), and (5) throw a compile error if there IS a return value in the function body.
+         *
+         * 7. Additionally, as a special case, the OS requires that `onKeyEvent()` be defined with `as boolean`
+         */
+        var _a, _b, _c, _d, _e;
+        if (((0, reflection_1.isFunctionStatement)(this.parent) || (0, reflection_1.isMethodStatement)(this.parent)) && ((_c = (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.tokens) === null || _b === void 0 ? void 0 : _b.name) === null || _c === void 0 ? void 0 : _c.text.toLowerCase()) === 'onkeyevent') {
+            // onKeyEvent() requires 'as Boolean' otherwise RokuOS throws errors
+            return true;
+        }
+        const isSub = ((_d = this.tokens.functionType) === null || _d === void 0 ? void 0 : _d.text.toLowerCase()) === 'sub';
+        const returnType = (_e = this.returnTypeExpression) === null || _e === void 0 ? void 0 : _e.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+        const isVoidReturnType = (0, reflection_1.isVoidType)(returnType);
+        if (isSub && !isVoidReturnType) { // format (6)
+            return true;
+        }
+        else if (isVoidReturnType) { // format (3)
+            return true;
+        }
+        return false;
+    }
+    clone() {
+        var _a, _b, _c;
+        return this.finalizeClone(new FunctionExpression({
+            parameters: (_a = this.parameters) === null || _a === void 0 ? void 0 : _a.map(e => e === null || e === void 0 ? void 0 : e.clone()),
+            body: (_b = this.body) === null || _b === void 0 ? void 0 : _b.clone(),
+            functionType: util_1.default.cloneToken(this.tokens.functionType),
+            endFunctionType: util_1.default.cloneToken(this.tokens.endFunctionType),
+            leftParen: util_1.default.cloneToken(this.tokens.leftParen),
+            rightParen: util_1.default.cloneToken(this.tokens.rightParen),
+            as: util_1.default.cloneToken(this.tokens.as),
+            returnTypeExpression: (_c = this.returnTypeExpression) === null || _c === void 0 ? void 0 : _c.clone()
+        }), ['body', 'returnTypeExpression']);
     }
 }
 exports.FunctionExpression = FunctionExpression;
-class FunctionParameterExpression extends Expression {
-    constructor(name, type, equalsToken, defaultValue, asToken, typeToken, namespaceName) {
+class FunctionParameterExpression extends AstNode_1.Expression {
+    constructor(options) {
         super();
-        this.name = name;
-        this.type = type;
-        this.equalsToken = equalsToken;
-        this.defaultValue = defaultValue;
-        this.asToken = asToken;
-        this.typeToken = typeToken;
-        this.namespaceName = namespaceName;
-    }
-    get range() {
-        return {
-            start: this.name.range.start,
-            end: this.typeToken ? this.typeToken.range.end : this.name.range.end
+        this.kind = AstNode_1.AstNodeKind.FunctionParameterExpression;
+        this.tokens = {
+            name: options.name,
+            equals: options.equals,
+            as: options.as
         };
+        this.defaultValue = options.defaultValue;
+        this.typeExpression = options.typeExpression;
+    }
+    getType(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const docs = BrightScriptDocParser_1.brsDocParser.parseNode(this.findAncestor(reflection_1.isFunctionStatement));
+        const paramName = this.tokens.name.text;
+        let paramTypeFromCode = (_b = (_a = this.typeExpression) === null || _a === void 0 ? void 0 : _a.getType(Object.assign(Object.assign({}, options), { flags: 2 /* SymbolTypeFlag.typetime */, typeChain: undefined }))) !== null && _b !== void 0 ? _b : util_1.default.getDefaultTypeFromValueType((_c = this.defaultValue) === null || _c === void 0 ? void 0 : _c.getType(Object.assign(Object.assign({}, options), { flags: 1 /* SymbolTypeFlag.runtime */, typeChain: undefined })));
+        if ((0, reflection_1.isInvalidType)(paramTypeFromCode) || (0, reflection_1.isVoidType)(paramTypeFromCode)) {
+            paramTypeFromCode = undefined;
+        }
+        const paramTypeFromDoc = docs.getParamBscType(paramName, Object.assign(Object.assign({}, options), { fullName: paramName, typeChain: undefined, tableProvider: () => this.getSymbolTable() }));
+        const paramType = (_d = util_1.default.chooseTypeFromCodeOrDocComment(paramTypeFromCode, paramTypeFromDoc, options)) !== null && _d !== void 0 ? _d : DynamicType_1.DynamicType.instance;
+        const docDescription = (_e = docs.getParam(paramName)) === null || _e === void 0 ? void 0 : _e.description;
+        if (docDescription) {
+            options.data = (_f = options.data) !== null && _f !== void 0 ? _f : {};
+            options.data.description = docDescription;
+        }
+        (_g = options.typeChain) === null || _g === void 0 ? void 0 : _g.push(new interfaces_1.TypeChainEntry({ name: paramName, type: paramType, data: options.data, astNode: this }));
+        return paramType;
+    }
+    get location() {
+        return util_1.default.createBoundingLocation(this.tokens.name, this.tokens.as, this.typeExpression, this.tokens.equals, this.defaultValue);
     }
     transpile(state) {
+        var _a, _b;
         let result = [
             //name
-            state.transpileToken(this.name)
+            state.transpileToken(this.tokens.name)
         ];
         //default value
         if (this.defaultValue) {
@@ -235,313 +426,491 @@ class FunctionParameterExpression extends Expression {
             result.push(this.defaultValue.transpile(state));
         }
         //type declaration
-        if (this.asToken) {
+        if (this.typeExpression && !state.options.removeParameterTypes) {
             result.push(' ');
-            result.push(state.transpileToken(this.asToken));
+            result.push(state.transpileToken(this.tokens.as, 'as'));
             result.push(' ');
-            result.push(state.sourceNode(this.typeToken, this.type.toTypeString()));
+            result.push(...((_b = (_a = this.typeExpression) === null || _a === void 0 ? void 0 : _a.transpile(state)) !== null && _b !== void 0 ? _b : []));
         }
         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);
-        }
-    }
-    get isOptional() {
-        return !!this.defaultValue;
-    }
-}
-exports.FunctionParameterExpression = FunctionParameterExpression;
-class NamespacedVariableNameExpression extends Expression {
-    constructor(
-    //if this is a `DottedGetExpression`, it must be comprised only of `VariableExpression`s
-    expression) {
-        super();
-        this.expression = expression;
-        this.range = expression.range;
-    }
-    transpile(state) {
-        return [
-            state.sourceNode(this, this.getName(Parser_1.ParseMode.BrightScript))
-        ];
-    }
-    getNameParts() {
-        let parts = [];
-        if (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) {
-                expr = expr.obj;
-                parts.unshift(expr.name.text);
+    getTypedef(state) {
+        var _a, _b, _c;
+        const results = [this.tokens.name.text];
+        if (this.defaultValue) {
+            results.push(' = ', ...((_a = this.defaultValue.getTypedef(state)) !== null && _a !== void 0 ? _a : this.defaultValue.transpile(state)));
+        }
+        if (this.tokens.as) {
+            results.push(' as ');
+            // TODO: Is this conditional needed? Will typeToken always exist
+            // so long as `asToken` exists?
+            if (this.typeExpression) {
+                results.push(...((_c = (_b = this.typeExpression) === null || _b === void 0 ? void 0 : _b.getTypedef(state)) !== null && _c !== void 0 ? _c : ['']));
             }
         }
-        return parts;
-    }
-    getName(parseMode) {
-        if (parseMode === Parser_1.ParseMode.BrighterScript) {
-            return this.getNameParts().join('.');
-        }
-        else {
-            return this.getNameParts().join('_');
-        }
+        return results;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'expression', visitor, options);
+        // eslint-disable-next-line no-bitwise
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'defaultValue', visitor, options);
+            (0, visitors_2.walk)(this, 'typeExpression', visitor, options);
         }
     }
+    get leadingTrivia() {
+        return this.tokens.name.leadingTrivia;
+    }
+    clone() {
+        var _a, _b;
+        return this.finalizeClone(new FunctionParameterExpression({
+            name: util_1.default.cloneToken(this.tokens.name),
+            as: util_1.default.cloneToken(this.tokens.as),
+            typeExpression: (_a = this.typeExpression) === null || _a === void 0 ? void 0 : _a.clone(),
+            equals: util_1.default.cloneToken(this.tokens.equals),
+            defaultValue: (_b = this.defaultValue) === null || _b === void 0 ? void 0 : _b.clone()
+        }), ['typeExpression', 'defaultValue']);
+    }
 }
-exports.NamespacedVariableNameExpression = NamespacedVariableNameExpression;
-class DottedGetExpression extends Expression {
-    constructor(obj, name, dot) {
+exports.FunctionParameterExpression = FunctionParameterExpression;
+class DottedGetExpression extends AstNode_1.Expression {
+    constructor(options) {
         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.kind = AstNode_1.AstNodeKind.DottedGetExpression;
+        this.tokens = {
+            name: options.name,
+            dot: options.dot
+        };
+        this.obj = options.obj;
+        this.location = util_1.default.createBoundingLocation(this.obj, this.tokens.dot, this.tokens.name);
     }
     transpile(state) {
         //if the callee starts with a namespace name, transpile the name
         if (state.file.calleeStartsWithNamespace(this)) {
-            return new NamespacedVariableNameExpression(this).transpile(state);
+            return [
+                ...state.transpileLeadingCommentsForAstNode(this),
+                state.sourceNode(this, this.getName(Parser_1.ParseMode.BrightScript))
+            ];
         }
         else {
             return [
                 ...this.obj.transpile(state),
-                '.',
-                state.transpileToken(this.name)
+                state.transpileToken(this.tokens.dot, '.'),
+                state.transpileToken(this.tokens.name)
             ];
         }
     }
+    getTypedef(state) {
+        //always transpile the dots for typedefs
+        return [
+            ...this.obj.transpile(state),
+            state.transpileToken(this.tokens.dot),
+            state.transpileToken(this.tokens.name)
+        ];
+    }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'obj', visitor, options);
-        }
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'obj', visitor, options);
+        }
+    }
+    getType(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const objType = (_a = this.obj) === null || _a === void 0 ? void 0 : _a.getType(options);
+        let result = objType === null || objType === void 0 ? void 0 : objType.getMemberType((_b = this.tokens.name) === null || _b === void 0 ? void 0 : _b.text, options);
+        if (util_1.default.isClassUsedAsFunction(result, this, options)) {
+            // treat this class constructor as a function
+            result = FunctionType_1.FunctionType.instance;
+        }
+        (_c = options.typeChain) === null || _c === void 0 ? void 0 : _c.push(new interfaces_1.TypeChainEntry({
+            name: (_d = this.tokens.name) === null || _d === void 0 ? void 0 : _d.text,
+            type: result,
+            data: options.data,
+            location: (_f = (_e = this.tokens.name) === null || _e === void 0 ? void 0 : _e.location) !== null && _f !== void 0 ? _f : this.location,
+            astNode: this
+        }));
+        if (result ||
+            options.flags & 2 /* SymbolTypeFlag.typetime */ ||
+            ((0, reflection_1.isPrimitiveType)(objType) || (0, reflection_1.isCallableType)(objType))) {
+            // All types should be known at typeTime, or the obj is well known
+            return result;
+        }
+        // It is possible at runtime that a value has been added dynamically to an object, or something
+        // TODO: maybe have a strict flag on this?
+        return DynamicType_1.DynamicType.instance;
+    }
+    getName(parseMode) {
+        return util_1.default.getAllDottedGetPartsAsString(this, parseMode);
+    }
+    get leadingTrivia() {
+        return this.obj.leadingTrivia;
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new DottedGetExpression({
+            obj: (_a = this.obj) === null || _a === void 0 ? void 0 : _a.clone(),
+            dot: util_1.default.cloneToken(this.tokens.dot),
+            name: util_1.default.cloneToken(this.tokens.name)
+        }), ['obj']);
     }
 }
 exports.DottedGetExpression = DottedGetExpression;
-class XmlAttributeGetExpression extends Expression {
-    constructor(obj, name, at) {
+class XmlAttributeGetExpression extends AstNode_1.Expression {
+    constructor(options) {
         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.kind = AstNode_1.AstNodeKind.XmlAttributeGetExpression;
+        this.obj = options.obj;
+        this.tokens = { at: options.at, name: options.name };
+        this.location = util_1.default.createBoundingLocation(this.obj, this.tokens.at, this.tokens.name);
     }
     transpile(state) {
         return [
             ...this.obj.transpile(state),
-            '@',
-            state.transpileToken(this.name)
+            state.transpileToken(this.tokens.at, '@'),
+            state.transpileToken(this.tokens.name)
         ];
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'obj', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'obj', visitor, options);
         }
     }
+    get leadingTrivia() {
+        return this.obj.leadingTrivia;
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new XmlAttributeGetExpression({
+            obj: (_a = this.obj) === null || _a === void 0 ? void 0 : _a.clone(),
+            at: util_1.default.cloneToken(this.tokens.at),
+            name: util_1.default.cloneToken(this.tokens.name)
+        }), ['obj']);
+    }
 }
 exports.XmlAttributeGetExpression = XmlAttributeGetExpression;
-class IndexedGetExpression extends Expression {
-    constructor(obj, index, openingSquare, closingSquare) {
+class IndexedGetExpression extends AstNode_1.Expression {
+    constructor(options) {
+        var _a;
         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.kind = AstNode_1.AstNodeKind.IndexedGetExpression;
+        this.tokens = {
+            openingSquare: options.openingSquare,
+            closingSquare: options.closingSquare,
+            questionDot: options.questionDot
+        };
+        this.obj = options.obj;
+        this.indexes = options.indexes;
+        this.location = util_1.default.createBoundingLocation(this.obj, this.tokens.openingSquare, this.tokens.questionDot, this.tokens.openingSquare, ...(_a = this.indexes) !== null && _a !== void 0 ? _a : [], this.tokens.closingSquare);
     }
     transpile(state) {
-        return [
-            ...this.obj.transpile(state),
-            state.transpileToken(this.openingSquare),
-            ...this.index.transpile(state),
-            state.transpileToken(this.closingSquare)
-        ];
+        var _a;
+        const result = [];
+        result.push(...this.obj.transpile(state), this.tokens.questionDot ? state.transpileToken(this.tokens.questionDot) : '', state.transpileToken(this.tokens.openingSquare, '['));
+        for (let i = 0; i < this.indexes.length; i++) {
+            //add comma between indexes
+            if (i > 0) {
+                result.push(', ');
+            }
+            let index = this.indexes[i];
+            result.push(...((_a = index === null || index === void 0 ? void 0 : index.transpile(state)) !== null && _a !== void 0 ? _a : []));
+        }
+        result.push(state.transpileToken(this.tokens.closingSquare, ']'));
+        return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'obj', visitor, options);
-            visitors_1.walk(this, 'index', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'obj', visitor, options);
+            (0, visitors_2.walkArray)(this.indexes, visitor, options, this);
         }
     }
+    getType(options) {
+        const objType = this.obj.getType(options);
+        if ((0, reflection_1.isArrayType)(objType)) {
+            // This is used on an array. What is the default type of that array?
+            return objType.defaultType;
+        }
+        return super.getType(options);
+    }
+    get leadingTrivia() {
+        return this.obj.leadingTrivia;
+    }
+    clone() {
+        var _a, _b;
+        return this.finalizeClone(new IndexedGetExpression({
+            obj: (_a = this.obj) === null || _a === void 0 ? void 0 : _a.clone(),
+            questionDot: util_1.default.cloneToken(this.tokens.questionDot),
+            openingSquare: util_1.default.cloneToken(this.tokens.openingSquare),
+            indexes: (_b = this.indexes) === null || _b === void 0 ? void 0 : _b.map(x => x === null || x === void 0 ? void 0 : x.clone()),
+            closingSquare: util_1.default.cloneToken(this.tokens.closingSquare)
+        }), ['obj', 'indexes']);
+    }
 }
 exports.IndexedGetExpression = IndexedGetExpression;
-class GroupingExpression extends Expression {
-    constructor(tokens, expression) {
+class GroupingExpression extends AstNode_1.Expression {
+    constructor(options) {
         super();
-        this.tokens = tokens;
-        this.expression = expression;
-        this.range = util_1.default.createRangeFromPositions(this.tokens.left.range.start, this.tokens.right.range.end);
+        this.kind = AstNode_1.AstNodeKind.GroupingExpression;
+        this.tokens = {
+            rightParen: options.rightParen,
+            leftParen: options.leftParen
+        };
+        this.expression = options.expression;
+        this.location = util_1.default.createBoundingLocation(this.tokens.leftParen, this.expression, this.tokens.rightParen);
     }
     transpile(state) {
+        if ((0, reflection_1.isTypecastExpression)(this.expression)) {
+            return this.expression.transpile(state);
+        }
         return [
-            state.transpileToken(this.tokens.left),
+            state.transpileToken(this.tokens.leftParen, '('),
             ...this.expression.transpile(state),
-            state.transpileToken(this.tokens.right)
+            state.transpileToken(this.tokens.rightParen, ')')
         ];
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'expression', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'expression', visitor, options);
         }
     }
+    getType(options) {
+        return this.expression.getType(options);
+    }
+    get leadingTrivia() {
+        var _a;
+        return (_a = this.tokens.leftParen) === null || _a === void 0 ? void 0 : _a.leadingTrivia;
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new GroupingExpression({
+            leftParen: util_1.default.cloneToken(this.tokens.leftParen),
+            expression: (_a = this.expression) === null || _a === void 0 ? void 0 : _a.clone(),
+            rightParen: util_1.default.cloneToken(this.tokens.rightParen)
+        }), ['expression']);
+    }
 }
 exports.GroupingExpression = GroupingExpression;
-class LiteralExpression extends Expression {
-    constructor(token) {
+class LiteralExpression extends AstNode_1.Expression {
+    constructor(options) {
         super();
-        this.token = token;
-        this.type = util_1.default.tokenToBscType(token);
+        this.kind = AstNode_1.AstNodeKind.LiteralExpression;
+        this.tokens = {
+            value: options.value
+        };
     }
-    get range() {
-        return this.token.range;
+    get location() {
+        return this.tokens.value.location;
+    }
+    getType(options) {
+        return util_1.default.tokenToBscType(this.tokens.value);
     }
     transpile(state) {
         let text;
-        if (this.token.kind === lexer_1.TokenKind.TemplateStringQuasi) {
+        if (this.tokens.value.kind === TokenKind_1.TokenKind.TemplateStringQuasi) {
             //wrap quasis with quotes (and escape inner quotemarks)
-            text = `"${this.token.text.replace(/"/g, '""')}"`;
+            text = `"${this.tokens.value.text.replace(/"/g, '""')}"`;
         }
-        else if (reflection_1.isStringType(this.type)) {
-            text = this.token.text;
+        else if (this.tokens.value.kind === TokenKind_1.TokenKind.StringLiteral) {
+            text = this.tokens.value.text;
             //add trailing quotemark if it's missing. We will have already generated a diagnostic for this.
             if (text.endsWith('"') === false) {
                 text += '"';
             }
         }
         else {
-            text = this.token.text;
+            text = this.tokens.value.text;
         }
         return [
-            state.sourceNode(this, text)
+            state.transpileToken(Object.assign(Object.assign({}, this.tokens.value), { text: text }))
         ];
     }
     walk(visitor, options) {
         //nothing to walk
     }
+    get leadingTrivia() {
+        return this.tokens.value.leadingTrivia;
+    }
+    clone() {
+        return this.finalizeClone(new LiteralExpression({
+            value: util_1.default.cloneToken(this.tokens.value)
+        }));
+    }
 }
 exports.LiteralExpression = LiteralExpression;
+/**
+ * The print statement can have a mix of expressions and separators. These separators represent actual output to the screen,
+ * so this AstNode represents those separators (comma, semicolon, and whitespace)
+ */
+class PrintSeparatorExpression extends AstNode_1.Expression {
+    constructor(options) {
+        super();
+        this.kind = AstNode_1.AstNodeKind.PrintSeparatorExpression;
+        this.tokens = {
+            separator: options.separator
+        };
+        this.location = this.tokens.separator.location;
+    }
+    transpile(state) {
+        var _a;
+        return [
+            ...(_a = this.tokens.separator.leadingWhitespace) !== null && _a !== void 0 ? _a : [],
+            ...state.transpileToken(this.tokens.separator)
+        ];
+    }
+    walk(visitor, options) {
+        //nothing to walk
+    }
+    get leadingTrivia() {
+        return this.tokens.separator.leadingTrivia;
+    }
+    clone() {
+        var _a;
+        return new PrintSeparatorExpression({
+            separator: util_1.default.cloneToken((_a = this.tokens) === null || _a === void 0 ? void 0 : _a.separator)
+        });
+    }
+}
+exports.PrintSeparatorExpression = PrintSeparatorExpression;
 /**
  * This is a special expression only used within template strings. It exists so we can prevent producing lots of empty strings
  * during template string transpile by identifying these expressions explicitly and skipping the bslib_toString around them
  */
-class EscapedCharCodeLiteralExpression extends Expression {
-    constructor(token) {
+class EscapedCharCodeLiteralExpression extends AstNode_1.Expression {
+    constructor(options) {
         super();
-        this.token = token;
-        this.range = token.range;
+        this.kind = AstNode_1.AstNodeKind.EscapedCharCodeLiteralExpression;
+        this.tokens = { value: options.value };
+        this.location = util_1.default.cloneLocation(this.tokens.value.location);
     }
     transpile(state) {
         return [
-            state.sourceNode(this, `chr(${this.token.charCode})`)
+            state.sourceNode(this, `chr(${this.tokens.value.charCode})`)
         ];
     }
     walk(visitor, options) {
         //nothing to walk
     }
+    clone() {
+        return this.finalizeClone(new EscapedCharCodeLiteralExpression({
+            value: util_1.default.cloneToken(this.tokens.value)
+        }));
+    }
 }
 exports.EscapedCharCodeLiteralExpression = EscapedCharCodeLiteralExpression;
-class ArrayLiteralExpression extends Expression {
-    constructor(elements, open, close, hasSpread = false) {
+class ArrayLiteralExpression extends AstNode_1.Expression {
+    constructor(options) {
+        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.kind = AstNode_1.AstNodeKind.ArrayLiteralExpression;
+        this.tokens = {
+            open: options.open,
+            close: options.close
+        };
+        this.elements = options.elements;
+        this.location = util_1.default.createBoundingLocation(this.tokens.open, ...(_a = this.elements) !== null && _a !== void 0 ? _a : [], this.tokens.close);
     }
     transpile(state) {
+        var _a;
         let result = [];
-        result.push(state.transpileToken(this.open));
+        result.push(state.transpileToken(this.tokens.open, '['));
         let hasChildren = this.elements.length > 0;
         state.blockDepth++;
         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 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(' ');
-                }
-                else {
-                    result.push('\n', state.indent());
-                }
-                state.lineage.unshift(this);
-                result.push(element.transpile(state));
-                state.lineage.shift();
+            if (util_1.default.isLeadingCommentOnSameLine(previousElement !== null && previousElement !== void 0 ? previousElement : this.tokens.open, element)) {
+                result.push(' ');
             }
             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;
-                    }
-                }
+                result.push('\n', state.indent());
             }
+            result.push(...element.transpile(state));
         }
         state.blockDepth--;
         //add a newline between open and close if there are elements
-        if (hasChildren) {
-            result.push('\n');
-            result.push(state.indent());
-        }
-        result.push(state.transpileToken(this.close));
+        const lastLocatable = (_a = this.elements[this.elements.length - 1]) !== null && _a !== void 0 ? _a : this.tokens.open;
+        result.push(...state.transpileEndBlockToken(lastLocatable, this.tokens.close, ']', hasChildren));
         return result;
     }
     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);
-            }
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walkArray)(this.elements, visitor, options, this);
         }
     }
+    getType(options) {
+        const innerTypes = this.elements.map(expr => expr.getType(options));
+        return new ArrayType_1.ArrayType(...innerTypes);
+    }
+    get leadingTrivia() {
+        var _a;
+        return (_a = this.tokens.open) === null || _a === void 0 ? void 0 : _a.leadingTrivia;
+    }
+    get endTrivia() {
+        var _a;
+        return (_a = this.tokens.close) === null || _a === void 0 ? void 0 : _a.leadingTrivia;
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new ArrayLiteralExpression({
+            elements: (_a = this.elements) === null || _a === void 0 ? void 0 : _a.map(e => e === null || e === void 0 ? void 0 : e.clone()),
+            open: util_1.default.cloneToken(this.tokens.open),
+            close: util_1.default.cloneToken(this.tokens.close)
+        }), ['elements']);
+    }
 }
 exports.ArrayLiteralExpression = ArrayLiteralExpression;
-class AAMemberExpression extends Expression {
-    constructor(keyToken, colonToken, 
-    /** The expression evaluated to determine the member's initial value. */
-    value) {
+class AAMemberExpression extends AstNode_1.Expression {
+    constructor(options) {
         super();
-        this.keyToken = keyToken;
-        this.colonToken = colonToken;
-        this.value = value;
-        this.range = util_1.default.createRangeFromPositions(keyToken.range.start, this.value.range.end);
+        this.kind = AstNode_1.AstNodeKind.AAMemberExpression;
+        this.tokens = {
+            key: options.key,
+            colon: options.colon,
+            comma: options.comma
+        };
+        this.value = options.value;
+        this.location = util_1.default.createBoundingLocation(this.tokens.key, this.tokens.colon, 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_2.walk)(this, 'value', visitor, options);
+    }
+    getType(options) {
+        return this.value.getType(options);
+    }
+    get leadingTrivia() {
+        return this.tokens.key.leadingTrivia;
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new AAMemberExpression({
+            key: util_1.default.cloneToken(this.tokens.key),
+            colon: util_1.default.cloneToken(this.tokens.colon),
+            value: (_a = this.value) === null || _a === void 0 ? void 0 : _a.clone()
+        }), ['value']);
     }
 }
 exports.AAMemberExpression = AAMemberExpression;
-class AALiteralExpression extends Expression {
-    constructor(elements, open, close) {
+class AALiteralExpression extends AstNode_1.Expression {
+    constructor(options) {
+        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.kind = AstNode_1.AstNodeKind.AALiteralExpression;
+        this.tokens = {
+            open: options.open,
+            close: options.close
+        };
+        this.elements = options.elements;
+        this.location = util_1.default.createBoundingLocation(this.tokens.open, ...(_a = this.elements) !== null && _a !== void 0 ? _a : [], this.tokens.close);
     }
     transpile(state) {
+        var _a;
         let result = [];
         //open curly
-        result.push(state.transpileToken(this.open));
+        result.push(state.transpileToken(this.tokens.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 && !util_1.default.isLeadingCommentOnSameLine(this.tokens.open, this.elements[0])) {
             result.push('\n');
         }
         state.blockDepth++;
@@ -550,170 +919,282 @@ 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) &&
-                (util_1.default.linesTouch(this.open, element) || util_1.default.linesTouch(previousElement, element))) {
+            if (util_1.default.isLeadingCommentOnSameLine(this.tokens.open, element) ||
+                util_1.default.isLeadingCommentOnSameLine(previousElement, element)) {
                 result.push(' ');
-                //indent line
             }
             else {
+                //indent line
                 result.push(state.indent());
             }
-            //render comments
-            if (reflection_1.isCommentStatement(element)) {
-                result.push(...element.transpile(state));
-            }
-            else {
-                //key
-                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(',');
-                }
-            }
+            //key
+            result.push(state.transpileToken(element.tokens.key));
+            //colon
+            result.push(state.transpileToken(element.tokens.colon, ':'), ' ');
+            //value
+            result.push(...element.value.transpile(state));
             //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 && !util_1.default.isLeadingCommentOnSameLine(element, nextElement)) {
                 //add a newline between statements
-            }
-            else {
                 result.push('\n');
             }
         }
         state.blockDepth--;
-        //only indent the closing curly if we have children
-        if (hasChildren) {
-            result.push(state.indent());
-        }
-        //close curly
-        result.push(state.transpileToken(this.close));
+        const lastElement = (_a = this.elements[this.elements.length - 1]) !== null && _a !== void 0 ? _a : this.tokens.open;
+        result.push(...state.transpileEndBlockToken(lastElement, this.tokens.close, '}', hasChildren));
         return result;
     }
     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);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walkArray)(this.elements, visitor, options, this);
+        }
+    }
+    getType(options) {
+        var _a, _b, _c;
+        const resultType = new AssociativeArrayType_1.AssociativeArrayType();
+        resultType.addBuiltInInterfaces();
+        for (const element of this.elements) {
+            if ((0, reflection_1.isAAMemberExpression)(element)) {
+                let memberName = (_c = (_b = (_a = element.tokens) === null || _a === void 0 ? void 0 : _a.key) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : '';
+                if (element.tokens.key.kind === TokenKind_1.TokenKind.StringLiteral) {
+                    memberName = memberName.replace(/"/g, ''); // remove quotes if it was a stringLiteral
                 }
-                else {
-                    visitors_1.walk(this.elements, i, visitor, options, this);
+                if (memberName) {
+                    resultType.addMember(memberName, { definingNode: element }, element.getType(options), 1 /* SymbolTypeFlag.runtime */);
                 }
             }
         }
+        return resultType;
+    }
+    get leadingTrivia() {
+        var _a;
+        return (_a = this.tokens.open) === null || _a === void 0 ? void 0 : _a.leadingTrivia;
+    }
+    get endTrivia() {
+        var _a;
+        return (_a = this.tokens.close) === null || _a === void 0 ? void 0 : _a.leadingTrivia;
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new AALiteralExpression({
+            elements: (_a = this.elements) === null || _a === void 0 ? void 0 : _a.map(e => e === null || e === void 0 ? void 0 : e.clone()),
+            open: util_1.default.cloneToken(this.tokens.open),
+            close: util_1.default.cloneToken(this.tokens.close)
+        }), ['elements']);
     }
 }
 exports.AALiteralExpression = AALiteralExpression;
-class UnaryExpression extends Expression {
-    constructor(operator, right) {
+class UnaryExpression extends AstNode_1.Expression {
+    constructor(options) {
         super();
-        this.operator = operator;
-        this.right = right;
-        this.range = util_1.default.createRangeFromPositions(this.operator.range.start, this.right.range.end);
+        this.kind = AstNode_1.AstNodeKind.UnaryExpression;
+        this.tokens = {
+            operator: options.operator
+        };
+        this.right = options.right;
+        this.location = util_1.default.createBoundingLocation(this.tokens.operator, this.right);
     }
     transpile(state) {
+        let separatingWhitespace;
+        if ((0, reflection_1.isVariableExpression)(this.right)) {
+            separatingWhitespace = this.right.tokens.name.leadingWhitespace;
+        }
+        else if ((0, reflection_1.isLiteralExpression)(this.right)) {
+            separatingWhitespace = this.right.tokens.value.leadingWhitespace;
+        }
+        else {
+            separatingWhitespace = ' ';
+        }
         return [
-            state.transpileToken(this.operator),
-            ' ',
+            state.transpileToken(this.tokens.operator),
+            separatingWhitespace,
             ...this.right.transpile(state)
         ];
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'right', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'right', visitor, options);
         }
     }
+    getType(options) {
+        return util_1.default.unaryOperatorResultType(this.tokens.operator, this.right.getType(options));
+    }
+    get leadingTrivia() {
+        return this.tokens.operator.leadingTrivia;
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new UnaryExpression({
+            operator: util_1.default.cloneToken(this.tokens.operator),
+            right: (_a = this.right) === null || _a === void 0 ? void 0 : _a.clone()
+        }), ['right']);
+    }
 }
 exports.UnaryExpression = UnaryExpression;
-class VariableExpression extends Expression {
-    constructor(name, namespaceName) {
+class VariableExpression extends AstNode_1.Expression {
+    constructor(options) {
+        var _a;
         super();
-        this.name = name;
-        this.namespaceName = namespaceName;
-        this.range = this.name.range;
+        this.kind = AstNode_1.AstNodeKind.VariableExpression;
+        this.tokens = {
+            name: options.name
+        };
+        this.location = util_1.default.cloneLocation((_a = this.tokens.name) === null || _a === void 0 ? void 0 : _a.location);
     }
     getName(parseMode) {
-        return parseMode === Parser_1.ParseMode.BrightScript ? this.name.text : this.name.text;
+        return this.tokens.name.text;
     }
     transpile(state) {
-        var _a;
         let result = [];
+        const namespace = this.findAncestor(reflection_1.isNamespaceStatement);
         //if the callee is the name of a known namespace function
-        if (state.file.calleeIsKnownNamespaceFunction(this, (_a = this.namespaceName) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript))) {
-            result.push(state.sourceNode(this, [
-                this.namespaceName.getName(Parser_1.ParseMode.BrightScript),
+        if (namespace && util_1.default.isCalleeMemberOfNamespace(this.tokens.name.text, this, namespace)) {
+            result.push(
+            //transpile leading comments since the token isn't being transpiled directly
+            ...state.transpileLeadingCommentsForAstNode(this), state.sourceNode(this, [
+                namespace.getName(Parser_1.ParseMode.BrightScript),
                 '_',
                 this.getName(Parser_1.ParseMode.BrightScript)
             ]));
             //transpile  normally
         }
         else {
-            result.push(state.transpileToken(this.name));
+            result.push(state.transpileToken(this.tokens.name));
         }
         return result;
     }
+    getTypedef(state) {
+        return [
+            state.transpileToken(this.tokens.name)
+        ];
+    }
     walk(visitor, options) {
         //nothing to walk
     }
+    getType(options) {
+        var _a;
+        let resultType = util_1.default.tokenToBscType(this.tokens.name);
+        const nameKey = this.getName();
+        if (!resultType) {
+            const symbolTable = this.getSymbolTable();
+            resultType = symbolTable === null || symbolTable === void 0 ? void 0 : symbolTable.getSymbolType(nameKey, Object.assign(Object.assign({}, options), { statementIndex: this.statementIndex, fullName: nameKey, tableProvider: () => this.getSymbolTable() }));
+            if (util_1.default.isClassUsedAsFunction(resultType, this, options)) {
+                resultType = FunctionType_1.FunctionType.instance;
+            }
+        }
+        (_a = options === null || options === void 0 ? void 0 : options.typeChain) === null || _a === void 0 ? void 0 : _a.push(new interfaces_1.TypeChainEntry({ name: nameKey, type: resultType, data: options.data, astNode: this }));
+        return resultType;
+    }
+    get leadingTrivia() {
+        return this.tokens.name.leadingTrivia;
+    }
+    clone() {
+        return this.finalizeClone(new VariableExpression({
+            name: util_1.default.cloneToken(this.tokens.name)
+        }));
+    }
 }
 exports.VariableExpression = VariableExpression;
-class SourceLiteralExpression extends Expression {
-    constructor(token) {
+class SourceLiteralExpression extends AstNode_1.Expression {
+    constructor(options) {
+        var _a;
         super();
-        this.token = token;
-        this.range = token.range;
+        this.kind = AstNode_1.AstNodeKind.SourceLiteralExpression;
+        this.tokens = {
+            value: options.value
+        };
+        this.location = util_1.default.cloneLocation((_a = this.tokens.value) === null || _a === void 0 ? void 0 : _a.location);
+    }
+    /**
+     * Find the index of the function in its parent
+     */
+    findFunctionIndex(parentFunction, func) {
+        let index = -1;
+        parentFunction.findChild((node) => {
+            if ((0, reflection_1.isFunctionExpression)(node)) {
+                index++;
+                if (node === func) {
+                    return true;
+                }
+            }
+        }, {
+            walkMode: visitors_1.WalkMode.visitAllRecursive
+        });
+        return index;
     }
     getFunctionName(state, parseMode) {
-        let functionExpression = state.file.getFunctionExpressionAtPosition(this.token.range.start);
+        let func = this.findAncestor(reflection_1.isFunctionExpression);
         let nameParts = [];
-        while (functionExpression.parentFunction) {
-            let index = functionExpression.parentFunction.childFunctionExpressions.indexOf(functionExpression);
+        let parentFunction;
+        while ((parentFunction = func.findAncestor(reflection_1.isFunctionExpression))) {
+            let index = this.findFunctionIndex(parentFunction, func);
             nameParts.unshift(`anon${index}`);
-            functionExpression = functionExpression.parentFunction;
+            func = parentFunction;
         }
         //get the index of this function in its parent
-        nameParts.unshift(functionExpression.functionStatement.getName(parseMode));
+        if ((0, reflection_1.isFunctionStatement)(func.parent)) {
+            nameParts.unshift(func.parent.getName(parseMode));
+        }
         return nameParts.join('$');
     }
+    /**
+     * Get the line number from our token or from the closest ancestor that has a range
+     */
+    getClosestLineNumber() {
+        var _a;
+        let node = this;
+        while (node) {
+            if ((_a = node.location) === null || _a === void 0 ? void 0 : _a.range) {
+                return node.location.range.start.line + 1;
+            }
+            node = node.parent;
+        }
+        return -1;
+    }
     transpile(state) {
+        var _a;
         let text;
-        switch (this.token.kind) {
-            case lexer_1.TokenKind.SourceFilePathLiteral:
+        switch (this.tokens.value.kind) {
+            case TokenKind_1.TokenKind.SourceFilePathLiteral:
                 const pathUrl = fileUrl(state.srcPath);
                 text = `"${pathUrl.substring(0, 4)}" + "${pathUrl.substring(4)}"`;
                 break;
-            case lexer_1.TokenKind.SourceLineNumLiteral:
-                text = `${this.token.range.start.line + 1}`;
+            case TokenKind_1.TokenKind.SourceLineNumLiteral:
+                //TODO find first parent that has range, or default to -1
+                text = `${this.getClosestLineNumber()}`;
                 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:
+            case TokenKind_1.TokenKind.SourceNamespaceNameLiteral:
+                let namespaceParts = this.getFunctionName(state, Parser_1.ParseMode.BrighterScript).split('.');
+                namespaceParts.pop(); // remove the function name
+                text = `"${namespaceParts.join('.')}"`;
+                break;
+            case TokenKind_1.TokenKind.SourceNamespaceRootNameLiteral:
+                let namespaceRootParts = this.getFunctionName(state, Parser_1.ParseMode.BrighterScript).split('.');
+                namespaceRootParts.pop(); // remove the function name
+                let rootNamespace = (_a = namespaceRootParts.shift()) !== null && _a !== void 0 ? _a : '';
+                text = `"${rootNamespace}"`;
+                break;
+            case TokenKind_1.TokenKind.SourceLocationLiteral:
                 const locationUrl = fileUrl(state.srcPath);
-                text = `"${locationUrl.substring(0, 4)}" + "${locationUrl.substring(4)}:${this.token.range.start.line + 1}"`;
+                //TODO find first parent that has range, or default to -1
+                text = `"${locationUrl.substring(0, 4)}" + "${locationUrl.substring(4)}:${this.getClosestLineNumber()}"`;
                 break;
-            case lexer_1.TokenKind.PkgPathLiteral:
-                text = `"${state.file.pkgPath.replace(/\.bs$/i, '.brs')}"`;
+            case TokenKind_1.TokenKind.PkgPathLiteral:
+                text = `"${util_1.default.sanitizePkgPath(state.file.pkgPath)}"`;
                 break;
-            case lexer_1.TokenKind.PkgLocationLiteral:
-                text = `"${state.file.pkgPath.replace(/\.bs$/i, '.brs')}:" + str(LINE_NUM)`;
+            case TokenKind_1.TokenKind.PkgLocationLiteral:
+                text = `"${util_1.default.sanitizePkgPath(state.file.pkgPath)}:" + 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;
+                text = this.tokens.value.text;
                 break;
         }
         return [
@@ -723,6 +1204,14 @@ class SourceLiteralExpression extends Expression {
     walk(visitor, options) {
         //nothing to walk
     }
+    get leadingTrivia() {
+        return this.tokens.value.leadingTrivia;
+    }
+    clone() {
+        return this.finalizeClone(new SourceLiteralExpression({
+            value: util_1.default.cloneToken(this.tokens.value)
+        }));
+    }
 }
 exports.SourceLiteralExpression = SourceLiteralExpression;
 /**
@@ -730,61 +1219,84 @@ exports.SourceLiteralExpression = SourceLiteralExpression;
  * except we need to uniquely identify these statements so we can
  * do more type checking.
  */
-class NewExpression extends Expression {
-    constructor(newKeyword, call) {
+class NewExpression extends AstNode_1.Expression {
+    constructor(options) {
         super();
-        this.newKeyword = newKeyword;
-        this.call = call;
-        this.range = util_1.default.createRangeFromPositions(this.newKeyword.range.start, this.call.range.end);
+        this.kind = AstNode_1.AstNodeKind.NewExpression;
+        this.tokens = {
+            new: options.new
+        };
+        this.call = options.call;
+        this.location = util_1.default.createBoundingLocation(this.tokens.new, this.call);
     }
     /**
      * The name of the class to initialize (with optional namespace prefixed)
      */
     get className() {
         //the parser guarantees the callee of a new statement's call object will be
-        //a NamespacedVariableNameExpression
+        //either a VariableExpression or a DottedGet
         return this.call.callee;
     }
-    get namespaceName() {
-        return this.call.namespaceName;
-    }
     transpile(state) {
-        var _a, _b;
-        const cls = (_b = state.file.getClassFileLink(this.className.getName(Parser_1.ParseMode.BrighterScript), (_a = this.namespaceName) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript))) === null || _b === void 0 ? void 0 : _b.item;
+        var _a;
+        const namespace = this.findAncestor(reflection_1.isNamespaceStatement);
+        const cls = (_a = state.file.getClassFileLink(this.className.getName(Parser_1.ParseMode.BrighterScript), namespace === null || namespace === void 0 ? void 0 : namespace.getName(Parser_1.ParseMode.BrighterScript))) === null || _a === void 0 ? void 0 : _a.item;
         //new statements within a namespace block can omit the leading namespace if the class resides in that same namespace.
         //So we need to figure out if this is a namespace-omitted class, or if this class exists without a namespace.
         return this.call.transpile(state, cls === null || cls === void 0 ? void 0 : cls.getName(Parser_1.ParseMode.BrightScript));
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'call', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'call', visitor, options);
+        }
+    }
+    getType(options) {
+        const result = this.call.getType(options);
+        if (options.typeChain) {
+            // modify last typechain entry to show it is a new ...()
+            const lastEntry = options.typeChain[options.typeChain.length - 1];
+            if (lastEntry) {
+                lastEntry.astNode = this;
+            }
         }
+        return result;
+    }
+    get leadingTrivia() {
+        return this.tokens.new.leadingTrivia;
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new NewExpression({
+            new: util_1.default.cloneToken(this.tokens.new),
+            call: (_a = this.call) === null || _a === void 0 ? void 0 : _a.clone()
+        }), ['call']);
     }
 }
 exports.NewExpression = NewExpression;
-class CallfuncExpression extends Expression {
-    constructor(callee, operator, methodName, openingParen, args, closingParen) {
-        var _a, _b, _c;
+class CallfuncExpression extends AstNode_1.Expression {
+    constructor(options) {
+        var _a, _b;
         super();
-        this.callee = callee;
-        this.operator = operator;
-        this.methodName = methodName;
-        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.kind = AstNode_1.AstNodeKind.CallfuncExpression;
+        this.tokens = {
+            operator: options.operator,
+            methodName: options.methodName,
+            openingParen: options.openingParen,
+            closingParen: options.closingParen
+        };
+        this.callee = options.callee;
+        this.args = (_a = options.args) !== null && _a !== void 0 ? _a : [];
+        this.location = util_1.default.createBoundingLocation(this.callee, this.tokens.operator, this.tokens.methodName, this.tokens.openingParen, ...(_b = this.args) !== null && _b !== void 0 ? _b : [], this.tokens.closingParen);
     }
     transpile(state) {
+        var _a;
         let result = [];
-        result.push(...this.callee.transpile(state), state.sourceNode(this.operator, '.callfunc'), state.transpileToken(this.openingParen), 
+        result.push(...this.callee.transpile(state), state.sourceNode(this.tokens.operator, '.callfunc'), state.transpileToken(this.tokens.openingParen, '('), 
         //the name of the function
-        state.sourceNode(this.methodName, ['"', this.methodName.text, '"']), ', ');
-        //transpile args
-        //callfunc with zero args never gets called, so pass invalid as the first parameter if there are no args
-        if (this.args.length === 0) {
-            result.push('invalid');
-        }
-        else {
+        state.sourceNode(this.tokens.methodName, ['"', this.tokens.methodName.text, '"']));
+        if (((_a = this.args) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            result.push(', ');
+            //transpile args
             for (let i = 0; i < this.args.length; i++) {
                 //add comma between args
                 if (i > 0) {
@@ -794,28 +1306,50 @@ class CallfuncExpression extends Expression {
                 result.push(...arg.transpile(state));
             }
         }
-        result.push(state.transpileToken(this.closingParen));
+        else if (state.options.legacyCallfuncHandling) {
+            result.push(', ', 'invalid');
+        }
+        result.push(state.transpileToken(this.tokens.closingParen, ')'));
         return result;
     }
     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);
-            }
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'callee', visitor, options);
+            (0, visitors_2.walkArray)(this.args, visitor, options, this);
         }
     }
+    getType(options) {
+        var _a;
+        const result = (_a = util_1.default.getCallFuncType(this, this.tokens.methodName, options)) !== null && _a !== void 0 ? _a : DynamicType_1.DynamicType.instance;
+        return result;
+    }
+    get leadingTrivia() {
+        return this.callee.leadingTrivia;
+    }
+    clone() {
+        var _a, _b;
+        return this.finalizeClone(new CallfuncExpression({
+            callee: (_a = this.callee) === null || _a === void 0 ? void 0 : _a.clone(),
+            operator: util_1.default.cloneToken(this.tokens.operator),
+            methodName: util_1.default.cloneToken(this.tokens.methodName),
+            openingParen: util_1.default.cloneToken(this.tokens.openingParen),
+            args: (_b = this.args) === null || _b === void 0 ? void 0 : _b.map(e => e === null || e === void 0 ? void 0 : e.clone()),
+            closingParen: util_1.default.cloneToken(this.tokens.closingParen)
+        }), ['callee', 'args']);
+    }
 }
 exports.CallfuncExpression = CallfuncExpression;
 /**
  * Since template strings can contain newlines, we need to concatenate multiple strings together with chr() calls.
  * This is a single expression that represents the string contatenation of all parts of a single quasi.
  */
-class TemplateStringQuasiExpression extends Expression {
-    constructor(expressions) {
+class TemplateStringQuasiExpression extends AstNode_1.Expression {
+    constructor(options) {
+        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.kind = AstNode_1.AstNodeKind.TemplateStringQuasiExpression;
+        this.expressions = options.expressions;
+        this.location = util_1.default.createBoundingLocation(...(_a = this.expressions) !== null && _a !== void 0 ? _a : []);
     }
     transpile(state, skipEmptyStrings = true) {
         let result = [];
@@ -823,7 +1357,7 @@ class TemplateStringQuasiExpression extends Expression {
         for (let expression of this.expressions) {
             //skip empty strings
             //TODO what does an empty string literal expression look like?
-            if (expression.token.text === '' && skipEmptyStrings === true) {
+            if (expression.tokens.value.text === '' && skipEmptyStrings === true) {
                 continue;
             }
             result.push(plus, ...expression.transpile(state));
@@ -832,28 +1366,40 @@ class TemplateStringQuasiExpression extends Expression {
         return result;
     }
     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);
-            }
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walkArray)(this.expressions, visitor, options, this);
         }
     }
+    clone() {
+        var _a;
+        return this.finalizeClone(new TemplateStringQuasiExpression({
+            expressions: (_a = this.expressions) === null || _a === void 0 ? void 0 : _a.map(e => e === null || e === void 0 ? void 0 : e.clone())
+        }), ['expressions']);
+    }
 }
 exports.TemplateStringQuasiExpression = TemplateStringQuasiExpression;
-class TemplateStringExpression extends Expression {
-    constructor(openingBacktick, quasis, expressions, closingBacktick) {
+class TemplateStringExpression extends AstNode_1.Expression {
+    constructor(options) {
+        var _a, _b, _c;
         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);
+        this.kind = AstNode_1.AstNodeKind.TemplateStringExpression;
+        this.tokens = {
+            openingBacktick: options.openingBacktick,
+            closingBacktick: options.closingBacktick
+        };
+        this.quasis = options.quasis;
+        this.expressions = options.expressions;
+        this.location = util_1.default.createBoundingLocation(this.tokens.openingBacktick, (_a = this.quasis) === null || _a === void 0 ? void 0 : _a[0], (_b = this.quasis) === null || _b === void 0 ? void 0 : _b[((_c = this.quasis) === null || _c === void 0 ? void 0 : _c.length) - 1], this.tokens.closingBacktick);
+    }
+    getType(options) {
+        return StringType_1.StringType.instance;
     }
     transpile(state) {
-        if (this.quasis.length === 1 && this.expressions.length === 0) {
+        //if this is essentially just a normal brightscript string but with backticks, transpile it as a normal string without parens
+        if (this.expressions.length === 0 && this.quasis.length === 1 && this.quasis[0].expressions.length === 1) {
             return this.quasis[0].transpile(state);
         }
-        let result = [];
+        let result = ['('];
         let plus = '';
         //helper function to figure out when to include the plus
         function add(...items) {
@@ -871,8 +1417,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.getType()))) {
                     add(...expression.transpile(state));
                     //wrap all other expressions with a bslib_toString call to prevent runtime type mismatch errors
                 }
@@ -881,35 +1427,51 @@ class TemplateStringExpression extends Expression {
                 }
             }
         }
+        //the expression should be wrapped in parens so it can be used line a single expression at runtime
+        result.push(')');
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
+        var _a;
+        if (options.walkMode & visitors_2.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);
+            for (let i = 0; i < ((_a = this.quasis) === null || _a === void 0 ? void 0 : _a.length); i++) {
+                (0, visitors_2.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_2.walk)(this.expressions, i, visitor, options, this);
                 }
             }
         }
     }
+    clone() {
+        var _a, _b;
+        return this.finalizeClone(new TemplateStringExpression({
+            openingBacktick: util_1.default.cloneToken(this.tokens.openingBacktick),
+            quasis: (_a = this.quasis) === null || _a === void 0 ? void 0 : _a.map(e => e === null || e === void 0 ? void 0 : e.clone()),
+            expressions: (_b = this.expressions) === null || _b === void 0 ? void 0 : _b.map(e => e === null || e === void 0 ? void 0 : e.clone()),
+            closingBacktick: util_1.default.cloneToken(this.tokens.closingBacktick)
+        }), ['quasis', 'expressions']);
+    }
 }
 exports.TemplateStringExpression = TemplateStringExpression;
-class TaggedTemplateStringExpression extends Expression {
-    constructor(tagName, openingBacktick, quasis, expressions, closingBacktick) {
+class TaggedTemplateStringExpression extends AstNode_1.Expression {
+    constructor(options) {
+        var _a, _b, _c;
         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);
+        this.kind = AstNode_1.AstNodeKind.TaggedTemplateStringExpression;
+        this.tokens = {
+            tagName: options.tagName,
+            openingBacktick: options.openingBacktick,
+            closingBacktick: options.closingBacktick
+        };
+        this.quasis = options.quasis;
+        this.expressions = options.expressions;
+        this.location = util_1.default.createBoundingLocation(this.tokens.tagName, this.tokens.openingBacktick, (_a = this.quasis) === null || _a === void 0 ? void 0 : _a[0], (_b = this.quasis) === null || _b === void 0 ? void 0 : _b[((_c = this.quasis) === null || _c === void 0 ? void 0 : _c.length) - 1], this.tokens.closingBacktick);
     }
     transpile(state) {
         let result = [];
-        result.push(state.transpileToken(this.tagName), '([');
+        result.push(state.transpileToken(this.tokens.tagName), '([');
         //add quasis as the first array
         for (let i = 0; i < this.quasis.length; i++) {
             let quasi = this.quasis[i];
@@ -928,30 +1490,47 @@ class TaggedTemplateStringExpression extends Expression {
             }
             result.push(...expression.transpile(state));
         }
-        result.push(state.sourceNode(this.closingBacktick, '])'));
+        result.push(state.sourceNode(this.tokens.closingBacktick, '])'));
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
+        var _a;
+        if (options.walkMode & visitors_2.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);
+            for (let i = 0; i < ((_a = this.quasis) === null || _a === void 0 ? void 0 : _a.length); i++) {
+                (0, visitors_2.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_2.walk)(this.expressions, i, visitor, options, this);
                 }
             }
         }
     }
+    clone() {
+        var _a, _b;
+        return this.finalizeClone(new TaggedTemplateStringExpression({
+            tagName: util_1.default.cloneToken(this.tokens.tagName),
+            openingBacktick: util_1.default.cloneToken(this.tokens.openingBacktick),
+            quasis: (_a = this.quasis) === null || _a === void 0 ? void 0 : _a.map(e => e === null || e === void 0 ? void 0 : e.clone()),
+            expressions: (_b = this.expressions) === null || _b === void 0 ? void 0 : _b.map(e => e === null || e === void 0 ? void 0 : e.clone()),
+            closingBacktick: util_1.default.cloneToken(this.tokens.closingBacktick)
+        }), ['quasis', 'expressions']);
+    }
 }
 exports.TaggedTemplateStringExpression = TaggedTemplateStringExpression;
-class AnnotationExpression extends Expression {
-    constructor(atToken, nameToken) {
+class AnnotationExpression extends AstNode_1.Expression {
+    constructor(options) {
         super();
-        this.atToken = atToken;
-        this.nameToken = nameToken;
-        this.name = nameToken.text;
-        this.range = util_1.default.createRangeFromPositions(atToken.range.start, nameToken.range.end);
+        this.kind = AstNode_1.AstNodeKind.AnnotationExpression;
+        this.tokens = {
+            at: options.at,
+            name: options.name
+        };
+        this.call = options.call;
+        this.name = this.tokens.name.text;
+    }
+    get location() {
+        return util_1.default.createBoundingLocation(this.tokens.at, this.tokens.name, this.call);
     }
     /**
      * Convert annotation arguments to JavaScript types
@@ -963,8 +1542,13 @@ class AnnotationExpression extends Expression {
         }
         return this.call.args.map(e => expressionToValue(e, strict));
     }
+    get leadingTrivia() {
+        var _a;
+        return (_a = this.tokens.at) === null || _a === void 0 ? void 0 : _a.leadingTrivia;
+    }
     transpile(state) {
-        return [];
+        //transpile only our leading comments
+        return state.transpileComments(this.leadingTrivia);
     }
     walk(visitor, options) {
         //nothing to walk
@@ -977,37 +1561,51 @@ class AnnotationExpression extends Expression {
             ...((_b = (_a = this.call) === null || _a === void 0 ? void 0 : _a.transpile(state)) !== null && _b !== void 0 ? _b : [])
         ];
     }
+    clone() {
+        const clone = this.finalizeClone(new AnnotationExpression({
+            at: util_1.default.cloneToken(this.tokens.at),
+            name: util_1.default.cloneToken(this.tokens.name)
+        }));
+        return clone;
+    }
 }
 exports.AnnotationExpression = AnnotationExpression;
-class TernaryExpression extends Expression {
-    constructor(test, questionMarkToken, consequent, colonToken, alternate) {
-        var _a, _b, _c;
+class TernaryExpression extends AstNode_1.Expression {
+    constructor(options) {
         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.kind = AstNode_1.AstNodeKind.TernaryExpression;
+        this.tokens = {
+            questionMark: options.questionMark,
+            colon: options.colon
+        };
+        this.test = options.test;
+        this.consequent = options.consequent;
+        this.alternate = options.alternate;
+        this.location = util_1.default.createBoundingLocation(this.test, this.tokens.questionMark, this.consequent, this.tokens.colon, this.alternate);
     }
     transpile(state) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         let result = [];
-        let consequentInfo = util_1.default.getExpressionInfo(this.consequent);
-        let alternateInfo = util_1.default.getExpressionInfo(this.alternate);
+        const file = state.file;
+        let consequentInfo = util_1.default.getExpressionInfo(this.consequent, file);
+        let alternateInfo = util_1.default.getExpressionInfo(this.alternate, file);
         //get all unique variable names used in the consequent and alternate, and sort them alphabetically so the output is consistent
         let allUniqueVarNames = [...new Set([...consequentInfo.uniqueVarNames, ...alternateInfo.uniqueVarNames])].sort();
+        //discard names of global functions that cannot be passed by reference
+        allUniqueVarNames = allUniqueVarNames.filter(name => {
+            return !nonReferenceableFunctions.includes(name.toLowerCase());
+        });
         let mutatingExpressions = [
             ...consequentInfo.expressions,
             ...alternateInfo.expressions
         ].filter(e => e instanceof CallExpression || e instanceof CallfuncExpression || e instanceof DottedGetExpression);
         if (mutatingExpressions.length > 0) {
-            result.push(state.sourceNode(this.questionMarkToken, 
+            result.push(state.sourceNode(this.tokens.questionMark, 
             //write all the scope variables as parameters.
             //TODO handle when there are more than 31 parameters
-            `(function(__bsCondition, ${allUniqueVarNames.join(', ')})`), state.newline, 
+            `(function(${['__bsCondition', ...allUniqueVarNames].join(', ')})`), state.newline, 
             //double indent so our `end function` line is still indented one at the end
-            state.indent(2), state.sourceNode(this.test, `if __bsCondition then`), state.newline, state.indent(1), state.sourceNode((_a = this.consequent) !== null && _a !== void 0 ? _a : this.questionMarkToken, 'return '), ...(_c = (_b = this.consequent) === null || _b === void 0 ? void 0 : _b.transpile(state)) !== null && _c !== void 0 ? _c : [state.sourceNode(this.questionMarkToken, 'invalid')], state.newline, state.indent(-1), state.sourceNode((_d = this.consequent) !== null && _d !== void 0 ? _d : this.questionMarkToken, 'else'), state.newline, state.indent(1), state.sourceNode((_e = this.consequent) !== null && _e !== void 0 ? _e : this.questionMarkToken, 'return '), ...(_g = (_f = this.alternate) === null || _f === void 0 ? void 0 : _f.transpile(state)) !== null && _g !== void 0 ? _g : [state.sourceNode((_h = this.consequent) !== null && _h !== void 0 ? _h : this.questionMarkToken, 'invalid')], state.newline, state.indent(-1), state.sourceNode(this.questionMarkToken, 'end if'), state.newline, state.indent(-1), state.sourceNode(this.questionMarkToken, 'end function)('), ...this.test.transpile(state), state.sourceNode(this.questionMarkToken, `, ${allUniqueVarNames.join(', ')})`));
+            state.indent(2), state.sourceNode(this.test, `if __bsCondition then`), state.newline, state.indent(1), state.sourceNode((_a = this.consequent) !== null && _a !== void 0 ? _a : this.tokens.questionMark, 'return '), ...(_c = (_b = this.consequent) === null || _b === void 0 ? void 0 : _b.transpile(state)) !== null && _c !== void 0 ? _c : [state.sourceNode(this.tokens.questionMark, 'invalid')], state.newline, state.indent(-1), state.sourceNode((_d = this.consequent) !== null && _d !== void 0 ? _d : this.tokens.questionMark, 'else'), state.newline, state.indent(1), state.sourceNode((_e = this.consequent) !== null && _e !== void 0 ? _e : this.tokens.questionMark, 'return '), ...(_g = (_f = this.alternate) === null || _f === void 0 ? void 0 : _f.transpile(state)) !== null && _g !== void 0 ? _g : [state.sourceNode((_h = this.consequent) !== null && _h !== void 0 ? _h : this.tokens.questionMark, 'invalid')], state.newline, state.indent(-1), state.sourceNode(this.tokens.questionMark, 'end if'), state.newline, state.indent(-1), state.sourceNode(this.tokens.questionMark, 'end function)('), ...this.test.transpile(state), state.sourceNode(this.tokens.questionMark, `${['', ...allUniqueVarNames].join(', ')})`));
             state.blockDepth--;
         }
         else {
@@ -1016,33 +1614,52 @@ class TernaryExpression extends Expression {
         return result;
     }
     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);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'test', visitor, options);
+            (0, visitors_2.walk)(this, 'consequent', visitor, options);
+            (0, visitors_2.walk)(this, 'alternate', visitor, options);
         }
     }
+    get leadingTrivia() {
+        return this.test.leadingTrivia;
+    }
+    clone() {
+        var _a, _b, _c;
+        return this.finalizeClone(new TernaryExpression({
+            test: (_a = this.test) === null || _a === void 0 ? void 0 : _a.clone(),
+            questionMark: util_1.default.cloneToken(this.tokens.questionMark),
+            consequent: (_b = this.consequent) === null || _b === void 0 ? void 0 : _b.clone(),
+            colon: util_1.default.cloneToken(this.tokens.colon),
+            alternate: (_c = this.alternate) === null || _c === void 0 ? void 0 : _c.clone()
+        }), ['test', 'consequent', 'alternate']);
+    }
 }
 exports.TernaryExpression = TernaryExpression;
-class NullCoalescingExpression extends Expression {
-    constructor(consequent, questionQuestionToken, alternate) {
-        var _a;
+class NullCoalescingExpression extends AstNode_1.Expression {
+    constructor(options) {
         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.kind = AstNode_1.AstNodeKind.NullCoalescingExpression;
+        this.tokens = {
+            questionQuestion: options.questionQuestion
+        };
+        this.consequent = options.consequent;
+        this.alternate = options.alternate;
+        this.location = util_1.default.createBoundingLocation(this.consequent, this.tokens.questionQuestion, this.alternate);
     }
     transpile(state) {
         let result = [];
-        let consequentInfo = util_1.default.getExpressionInfo(this.consequent);
-        let alternateInfo = util_1.default.getExpressionInfo(this.alternate);
+        let consequentInfo = util_1.default.getExpressionInfo(this.consequent, state.file);
+        let alternateInfo = util_1.default.getExpressionInfo(this.alternate, state.file);
         //get all unique variable names used in the consequent and alternate, and sort them alphabetically so the output is consistent
         let allUniqueVarNames = [...new Set([...consequentInfo.uniqueVarNames, ...alternateInfo.uniqueVarNames])].sort();
+        //discard names of global functions that cannot be passed by reference
+        allUniqueVarNames = allUniqueVarNames.filter(name => {
+            return !nonReferenceableFunctions.includes(name.toLowerCase());
+        });
         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.
@@ -1060,51 +1677,343 @@ class NullCoalescingExpression extends Expression {
         return result;
     }
     walk(visitor, options) {
-        if (options.walkMode & visitors_1.InternalWalkMode.walkExpressions) {
-            visitors_1.walk(this, 'consequent', visitor, options);
-            visitors_1.walk(this, 'alternate', visitor, options);
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'consequent', visitor, options);
+            (0, visitors_2.walk)(this, 'alternate', visitor, options);
         }
     }
+    get leadingTrivia() {
+        return this.consequent.leadingTrivia;
+    }
+    clone() {
+        var _a, _b;
+        return this.finalizeClone(new NullCoalescingExpression({
+            consequent: (_a = this.consequent) === null || _a === void 0 ? void 0 : _a.clone(),
+            questionQuestion: util_1.default.cloneToken(this.tokens.questionQuestion),
+            alternate: (_b = this.alternate) === null || _b === void 0 ? void 0 : _b.clone()
+        }), ['consequent', 'alternate']);
+    }
 }
 exports.NullCoalescingExpression = NullCoalescingExpression;
+class RegexLiteralExpression extends AstNode_1.Expression {
+    constructor(options) {
+        super();
+        this.kind = AstNode_1.AstNodeKind.RegexLiteralExpression;
+        this.tokens = {
+            regexLiteral: options.regexLiteral
+        };
+    }
+    get location() {
+        var _a, _b;
+        return (_b = (_a = this.tokens) === null || _a === void 0 ? void 0 : _a.regexLiteral) === null || _b === void 0 ? void 0 : _b.location;
+    }
+    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
+    }
+    clone() {
+        return this.finalizeClone(new RegexLiteralExpression({
+            regexLiteral: util_1.default.cloneToken(this.tokens.regexLiteral)
+        }));
+    }
+    get leadingTrivia() {
+        var _a;
+        return (_a = this.tokens.regexLiteral) === null || _a === void 0 ? void 0 : _a.leadingTrivia;
+    }
+}
+exports.RegexLiteralExpression = RegexLiteralExpression;
 function expressionToValue(expr, strict) {
+    var _a;
     if (!expr) {
         return null;
     }
-    if (reflection_1.isUnaryExpression(expr) && reflection_1.isLiteralNumber(expr.right)) {
-        return numberExpressionToValue(expr.right, expr.operator.text);
+    if ((0, reflection_1.isUnaryExpression)(expr) && (0, reflection_1.isLiteralNumber)(expr.right)) {
+        return numberExpressionToValue(expr.right, expr.tokens.operator.text);
     }
-    if (reflection_1.isLiteralString(expr)) {
+    if ((0, reflection_1.isLiteralString)(expr)) {
         //remove leading and trailing quotes
-        return expr.token.text.replace(/^"/, '').replace(/"$/, '');
+        return expr.tokens.value.text.replace(/^"/, '').replace(/"$/, '');
     }
-    if (reflection_1.isLiteralNumber(expr)) {
+    if ((0, reflection_1.isLiteralNumber)(expr)) {
         return numberExpressionToValue(expr);
     }
-    if (reflection_1.isLiteralBoolean(expr)) {
-        return expr.token.text.toLowerCase() === 'true';
+    if ((0, reflection_1.isLiteralBoolean)(expr)) {
+        return expr.tokens.value.text.toLowerCase() === 'true';
     }
-    if (reflection_1.isArrayLiteralExpression(expr)) {
+    if ((0, reflection_1.isArrayLiteralExpression)(expr)) {
         return expr.elements
-            .filter(e => !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)) {
-                acc[e.keyToken.text] = expressionToValue(e.value, strict);
-            }
+            acc[e.tokens.key.text] = expressionToValue(e.value, strict);
             return acc;
         }, {});
     }
+    //for annotations, we only support serializing pure string values
+    if ((0, reflection_1.isTemplateStringExpression)(expr)) {
+        if (((_a = expr.quasis) === null || _a === void 0 ? void 0 : _a.length) === 1 && expr.expressions.length === 0) {
+            return expr.quasis[0].expressions.map(x => x.tokens.value.text).join('');
+        }
+    }
     return strict ? null : expr;
 }
 function numberExpressionToValue(expr, operator = '') {
-    if (reflection_1.isIntegerType(expr.type) || reflection_1.isLongIntegerType(expr.type)) {
-        return parseInt(operator + expr.token.text);
+    if ((0, reflection_1.isIntegerType)(expr.getType()) || (0, reflection_1.isLongIntegerType)(expr.getType())) {
+        return parseInt(operator + expr.tokens.value.text);
     }
     else {
-        return parseFloat(operator + expr.token.text);
+        return parseFloat(operator + expr.tokens.value.text);
+    }
+}
+class TypeExpression extends AstNode_1.Expression {
+    constructor(options) {
+        var _a;
+        super();
+        this.kind = AstNode_1.AstNodeKind.TypeExpression;
+        this.expression = options.expression;
+        this.location = util_1.default.cloneLocation((_a = this.expression) === null || _a === void 0 ? void 0 : _a.location);
+    }
+    transpile(state) {
+        const exprType = this.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+        if ((0, reflection_1.isNativeType)(exprType)) {
+            return this.expression.transpile(state);
+        }
+        return [exprType.toTypeString()];
+    }
+    walk(visitor, options) {
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'expression', visitor, options);
+        }
+    }
+    getType(options) {
+        return this.expression.getType(Object.assign(Object.assign({}, options), { flags: 2 /* SymbolTypeFlag.typetime */ }));
+    }
+    getTypedef(state) {
+        // TypeDefs should pass through any valid type names
+        return this.expression.transpile(state);
+    }
+    getName(parseMode = Parser_1.ParseMode.BrighterScript) {
+        //TODO: this may not support Complex Types, eg. generics or Unions
+        return util_1.default.getAllDottedGetPartsAsString(this.expression, parseMode);
+    }
+    getNameParts() {
+        //TODO: really, this code is only used to get Namespaces. It could be more clear.
+        return util_1.default.getAllDottedGetParts(this.expression).map(x => x.text);
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new TypeExpression({
+            expression: (_a = this.expression) === null || _a === void 0 ? void 0 : _a.clone()
+        }), ['expression']);
+    }
+}
+exports.TypeExpression = TypeExpression;
+class TypecastExpression extends AstNode_1.Expression {
+    constructor(options) {
+        super();
+        this.kind = AstNode_1.AstNodeKind.TypecastExpression;
+        this.tokens = {
+            as: options.as
+        };
+        this.obj = options.obj;
+        this.typeExpression = options.typeExpression;
+        this.location = util_1.default.createBoundingLocation(this.obj, this.tokens.as, this.typeExpression);
+    }
+    transpile(state) {
+        return this.obj.transpile(state);
+    }
+    walk(visitor, options) {
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'obj', visitor, options);
+            (0, visitors_2.walk)(this, 'typeExpression', visitor, options);
+        }
+    }
+    getType(options) {
+        const result = this.typeExpression.getType(options);
+        if (options.typeChain) {
+            // modify last typechain entry to show it is a typecast
+            const lastEntry = options.typeChain[options.typeChain.length - 1];
+            if (lastEntry) {
+                lastEntry.astNode = this;
+            }
+        }
+        return result;
+    }
+    clone() {
+        var _a, _b;
+        return this.finalizeClone(new TypecastExpression({
+            obj: (_a = this.obj) === null || _a === void 0 ? void 0 : _a.clone(),
+            as: util_1.default.cloneToken(this.tokens.as),
+            typeExpression: (_b = this.typeExpression) === null || _b === void 0 ? void 0 : _b.clone()
+        }), ['obj', 'typeExpression']);
+    }
+}
+exports.TypecastExpression = TypecastExpression;
+class TypedArrayExpression extends AstNode_1.Expression {
+    constructor(options) {
+        super();
+        this.kind = AstNode_1.AstNodeKind.TypedArrayExpression;
+        this.tokens = {
+            leftBracket: options.leftBracket,
+            rightBracket: options.rightBracket
+        };
+        this.innerType = options.innerType;
+        this.location = util_1.default.createBoundingLocation(this.innerType, this.tokens.leftBracket, this.tokens.rightBracket);
+    }
+    transpile(state) {
+        return [this.getType({ flags: 2 /* SymbolTypeFlag.typetime */ }).toTypeString()];
+    }
+    walk(visitor, options) {
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'innerType', visitor, options);
+        }
+    }
+    getType(options) {
+        return new ArrayType_1.ArrayType(this.innerType.getType(options));
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new TypedArrayExpression({
+            innerType: (_a = this.innerType) === null || _a === void 0 ? void 0 : _a.clone(),
+            leftBracket: util_1.default.cloneToken(this.tokens.leftBracket),
+            rightBracket: util_1.default.cloneToken(this.tokens.rightBracket)
+        }), ['innerType']);
     }
 }
+exports.TypedArrayExpression = TypedArrayExpression;
+class InlineInterfaceExpression extends AstNode_1.Expression {
+    constructor(options) {
+        super();
+        this.kind = AstNode_1.AstNodeKind.InlineInterfaceExpression;
+        this.tokens = {
+            open: options.open,
+            close: options.close
+        };
+        this.members = options.members;
+        this.location = util_1.default.createBoundingLocation(this.tokens.open, ...this.members, this.tokens.close);
+    }
+    get leadingTrivia() {
+        var _a;
+        return (_a = this.tokens.open) === null || _a === void 0 ? void 0 : _a.leadingTrivia;
+    }
+    transpile(state) {
+        return [this.getType({ flags: 2 /* SymbolTypeFlag.typetime */ }).toTypeString()];
+    }
+    walk(visitor, options) {
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walkArray)(this.members, visitor, options, this);
+        }
+    }
+    getType(options) {
+        var _a, _b, _c;
+        const resultType = new InlineInterfaceType_1.InlineInterfaceType();
+        for (const member of this.members) {
+            let memberName = (_c = (_b = (_a = member.tokens) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : '';
+            if (member.tokens.name.kind === TokenKind_1.TokenKind.StringLiteral) {
+                memberName = memberName.replace(/"/g, ''); // remove quotes if it was a stringLiteral
+            }
+            if (memberName) {
+                const memberType = member === null || member === void 0 ? void 0 : member.getType(Object.assign(Object.assign({}, options), { typeChain: undefined })); // no typechain info needed
+                let flag = 1 /* SymbolTypeFlag.runtime */;
+                if (member.isOptional) {
+                    flag |= 4 /* SymbolTypeFlag.optional */;
+                }
+                resultType.addMember(memberName, { definingNode: member }, memberType, flag);
+            }
+        }
+        return resultType;
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new InlineInterfaceExpression({
+            open: util_1.default.cloneToken(this.tokens.open),
+            members: (_a = this.members) === null || _a === void 0 ? void 0 : _a.map(x => x === null || x === void 0 ? void 0 : x.clone()),
+            close: util_1.default.cloneToken(this.tokens.close)
+        }), ['members']);
+    }
+}
+exports.InlineInterfaceExpression = InlineInterfaceExpression;
+class InlineInterfaceMemberExpression extends AstNode_1.Expression {
+    constructor(options) {
+        super();
+        this.kind = AstNode_1.AstNodeKind.InlineInterfaceMemberExpression;
+        this.tokens = {
+            name: options.name,
+            as: options.as,
+            optional: options.optional
+        };
+        this.typeExpression = options.typeExpression;
+        this.location = util_1.default.createBoundingLocation(this.tokens.optional, this.tokens.name, this.tokens.as, this.typeExpression);
+    }
+    get leadingTrivia() {
+        var _a, _b;
+        return (_b = (_a = this.tokens.optional) === null || _a === void 0 ? void 0 : _a.leadingTrivia) !== null && _b !== void 0 ? _b : this.tokens.name.leadingTrivia;
+    }
+    transpile(state) {
+        throw new Error('Method not implemented.');
+    }
+    walk(visitor, options) {
+        if (options.walkMode & visitors_2.InternalWalkMode.walkExpressions) {
+            (0, visitors_2.walk)(this, 'typeExpression', visitor, options);
+        }
+    }
+    getType(options) {
+        var _a, _b;
+        return (_b = (_a = this.typeExpression) === null || _a === void 0 ? void 0 : _a.getType(options)) !== null && _b !== void 0 ? _b : DynamicType_1.DynamicType.instance;
+    }
+    get isOptional() {
+        return !!this.tokens.optional;
+    }
+    clone() {
+        var _a;
+        return this.finalizeClone(new InlineInterfaceMemberExpression({
+            typeExpression: (_a = this.typeExpression) === null || _a === void 0 ? void 0 : _a.clone(),
+            as: util_1.default.cloneToken(this.tokens.as),
+            name: util_1.default.cloneToken(this.tokens.name),
+            optional: util_1.default.cloneToken(this.tokens.optional)
+        }), ['typeExpression']);
+    }
+}
+exports.InlineInterfaceMemberExpression = InlineInterfaceMemberExpression;
+/**
+ * A list of names of functions that are restricted from being stored to a
+ * variable, property, or passed as an argument. (i.e. `type` or `createobject`).
+ * Names are stored in lower case.
+ */
+const nonReferenceableFunctions = [
+    'createobject',
+    'type',
+    'getglobalaa',
+    'box',
+    'run',
+    'eval',
+    'getlastruncompileerror',
+    'getlastrunruntimeerror',
+    'tab',
+    'pos'
+];
 //# sourceMappingURL=Expression.js.map