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

package/dist/types/TypedFunctionType.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedFunctionType = void 0;
+const reflection_1 = require("../astUtils/reflection");
+const DynamicType_1 = require("./DynamicType");
+class TypedFunctionType {
+    constructor(returnType, 
+    /**
+     * Determines if this is a sub or not
+     */
+    isSub = false, params = [], isNew = false, isVariadic = false) {
+        this.returnType = returnType;
+        this.isSub = isSub;
+        this.params = params;
+        this.isNew = isNew;
+        this.isVariadic = isVariadic;
+    }
+    setName(name) {
+        this.name = name;
+        return this;
+    }
+    addParameter(paramOrName, type, isOptional) {
+        if (typeof paramOrName === 'string') {
+            this.params.push({
+                name: paramOrName,
+                type: type !== null && type !== void 0 ? type : new DynamicType_1.DynamicType(),
+                isOptional: isOptional === true ? true : false,
+                isRestArgument: false
+            });
+        }
+        else {
+            this.params.push(paramOrName);
+        }
+        return this;
+    }
+    isAssignableTo(targetType, context) {
+        if ((0, reflection_1.isObjectType)(targetType)) {
+            return true;
+        }
+        else if ((0, reflection_1.isTypedFunctionType)(targetType)) {
+            if (!targetType.isVariadic) {
+                //compare all parameters
+                let len = Math.max(this.params.length, targetType.params.length);
+                for (let i = 0; i < len; i++) {
+                    let myParam = this.params[i];
+                    let targetParam = targetType.params[i];
+                    if (!myParam || !targetParam || !myParam.type.isAssignableTo(targetParam.type, context)) {
+                        return false;
+                    }
+                }
+            }
+            //compare return type
+            if (!this.returnType || !targetType.returnType || !this.returnType.isAssignableTo(targetType.returnType, context)) {
+                return false;
+            }
+            //made it here, all params and return type are equivalent
+            return true;
+        }
+        else if ((0, reflection_1.isDynamicType)(targetType)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    isConvertibleTo(targetType, context) {
+        return this.isAssignableTo(targetType, context);
+    }
+    toString(context) {
+        var _a, _b;
+        let paramTexts = [];
+        for (let param of this.params) {
+            paramTexts.push(`${param.name}${param.isOptional ? '?' : ''} as ${param.type.toString(context)}`);
+        }
+        if (this.isNew) {
+            return `new ${(_a = this.name) !== null && _a !== void 0 ? _a : ''}(${paramTexts.join(', ')})`;
+        }
+        return `${this.isSub ? 'sub' : 'function'} ${(_b = this.name) !== null && _b !== void 0 ? _b : ''}(${paramTexts.join(', ')}) as ${this.returnType.toString(context)}`;
+    }
+    toTypeString() {
+        return 'Function';
+    }
+    equals(targetType, context) {
+        return ((0, reflection_1.isTypedFunctionType)(targetType)) && this.isAssignableTo(targetType, context);
+    }
+}
+exports.TypedFunctionType = TypedFunctionType;
+//# sourceMappingURL=TypedFunctionType.js.map

package/dist/types/TypedFunctionType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedFunctionType.js","sourceRoot":"","sources":["../../src/types/TypedFunctionType.ts"],"names":[],"mappings":"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"}

package/dist/types/TypedFunctionType.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/TypedFunctionType.spec.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const DynamicType_1 = require("./DynamicType");
+const FloatType_1 = require("./FloatType");
+const TypedFunctionType_1 = require("./TypedFunctionType");
+const IntegerType_1 = require("./IntegerType");
+const StringType_1 = require("./StringType");
+const FunctionType_1 = require("./FunctionType");
+const VoidType_1 = require("./VoidType");
+const ObjectType_1 = require("./ObjectType");
+describe('FunctionType', () => {
+    it('is equivalent to proper type', () => {
+        (0, chai_1.expect)(new TypedFunctionType_1.TypedFunctionType(new VoidType_1.VoidType()).isAssignableTo(new DynamicType_1.DynamicType())).to.be.true;
+        (0, chai_1.expect)(new TypedFunctionType_1.TypedFunctionType(new VoidType_1.VoidType()).isAssignableTo(new ObjectType_1.ObjectType())).to.be.true;
+    });
+    it('validates using param and return types', () => {
+        (0, chai_1.expect)(new TypedFunctionType_1.TypedFunctionType(new VoidType_1.VoidType()).isAssignableTo(new TypedFunctionType_1.TypedFunctionType(new VoidType_1.VoidType()))).to.be.true;
+        //different parameter count
+        (0, chai_1.expect)(new TypedFunctionType_1.TypedFunctionType(new VoidType_1.VoidType()).addParameter('a', new IntegerType_1.IntegerType(), false).isAssignableTo(new TypedFunctionType_1.TypedFunctionType(new VoidType_1.VoidType()))).to.be.false;
+        //different parameter types
+        (0, chai_1.expect)(new TypedFunctionType_1.TypedFunctionType(new VoidType_1.VoidType()).addParameter('a', new IntegerType_1.IntegerType(), false).isAssignableTo(new TypedFunctionType_1.TypedFunctionType(new VoidType_1.VoidType()).addParameter('a', new StringType_1.StringType(), false))).to.be.false;
+        //different return type
+        (0, chai_1.expect)(new TypedFunctionType_1.TypedFunctionType(new VoidType_1.VoidType()).isAssignableTo(new TypedFunctionType_1.TypedFunctionType(new IntegerType_1.IntegerType()))).to.be.false;
+    });
+    it('adds a callableParam object as a parameter', () => {
+        const myFunc = new TypedFunctionType_1.TypedFunctionType(new IntegerType_1.IntegerType(), false, [{ name: 'a', type: new StringType_1.StringType(), isOptional: false }, { name: 'b', type: new DynamicType_1.DynamicType(), isOptional: true }]);
+        myFunc.addParameter({ name: 'c', type: new FloatType_1.FloatType(), isOptional: true });
+        (0, chai_1.expect)(myFunc.params.length).to.equal(3);
+    });
+    it('is assignable to a universal function', () => {
+        (0, chai_1.expect)(new TypedFunctionType_1.TypedFunctionType(new StringType_1.StringType()).setName('myFunc').addParameter('p1', new IntegerType_1.IntegerType()).isAssignableTo(new FunctionType_1.FunctionType()));
+        (0, chai_1.expect)(new TypedFunctionType_1.TypedFunctionType(new DynamicType_1.DynamicType()).isAssignableTo(new FunctionType_1.FunctionType()));
+        (0, chai_1.expect)(new TypedFunctionType_1.TypedFunctionType(new VoidType_1.VoidType()).isAssignableTo(new FunctionType_1.FunctionType()));
+    });
+});
+//# sourceMappingURL=TypedFunctionType.spec.js.map

package/dist/types/TypedFunctionType.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedFunctionType.spec.js","sourceRoot":"","sources":["../../src/types/TypedFunctionType.spec.ts"],"names":[],"mappings":"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"}

package/dist/types/UninitializedType.js

@@ -6,8 +6,8 @@ class UninitializedType {
     // eslint-disable-next-line @typescript-eslint/no-useless-constructor
     constructor() { }
     isAssignableTo(targetType) {
-        return (reflection_1.isUninitializedType(targetType) ||
-            reflection_1.isDynamicType(targetType));
+        return ((0, reflection_1.isUninitializedType)(targetType) ||
+            (0, reflection_1.isDynamicType)(targetType));
     }
     isConvertibleTo(targetType) {
         return this.isAssignableTo(targetType);
@@ -19,7 +19,7 @@ class UninitializedType {
         return this.toString();
     }
     equals(targetType) {
-        return reflection_1.isUninitializedType(targetType);
+        return (0, reflection_1.isUninitializedType)(targetType);
     }
 }
 exports.UninitializedType = UninitializedType;

package/dist/types/UninitializedType.js.map

@@ -1 +1 @@
-{"version":3,"file":"UninitializedType.js","sourceRoot":"","sources":["../../src/types/UninitializedType.ts"],"names":[],"mappings":";;;AAAA,uDAA4E;AAG5E,MAAa,iBAAiB;IAE1B,qEAAqE;IACrE,gBAAgB,CAAC;IAEV,cAAc,CAAC,UAAmB;QACrC,OAAO,CACH,gCAAmB,CAAC,UAAU,CAAC;YAC/B,0BAAa,CAAC,UAAU,CAAC,CAC5B,CAAC;IACN,CAAC;IAEM,eAAe,CAAC,UAAmB;QACtC,OAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAEM,QAAQ;QACX,OAAO,eAAe,CAAC;IAC3B,CAAC;IAGM,YAAY;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAEM,MAAM,CAAC,UAAmB;QAC7B,OAAO,gCAAmB,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;CACJ;AA5BD,8CA4BC"}
+{"version":3,"file":"UninitializedType.js","sourceRoot":"","sources":["../../src/types/UninitializedType.ts"],"names":[],"mappings":";;;AAAA,uDAA4E;AAG5E,MAAa,iBAAiB;IAE1B,qEAAqE;IACrE,gBAAgB,CAAC;IAEV,cAAc,CAAC,UAAmB;QACrC,OAAO,CACH,IAAA,gCAAmB,EAAC,UAAU,CAAC;YAC/B,IAAA,0BAAa,EAAC,UAAU,CAAC,CAC5B,CAAC;IACN,CAAC;IAEM,eAAe,CAAC,UAAmB;QACtC,OAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAEM,QAAQ;QACX,OAAO,eAAe,CAAC;IAC3B,CAAC;IAEM,YAAY;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAEM,MAAM,CAAC,UAAmB;QAC7B,OAAO,IAAA,gCAAmB,EAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;CACJ;AA3BD,8CA2BC"}

package/dist/types/VoidType.d.ts

@@ -1,7 +1,9 @@
 import type { BscType } from './BscType';
 export declare class VoidType implements BscType {
-    isAssignableTo(targetType: BscType): any;
-    isConvertibleTo(targetType: BscType): any;
+    typeText?: string;
+    constructor(typeText?: string);
+    isAssignableTo(targetType: BscType): boolean;
+    isConvertibleTo(targetType: BscType): boolean;
     toString(): string;
     toTypeString(): string;
     equals(targetType: BscType): boolean;

package/dist/types/VoidType.js

@@ -3,21 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VoidType = void 0;
 const reflection_1 = require("../astUtils/reflection");
 class VoidType {
+    constructor(typeText) {
+        this.typeText = typeText;
+    }
     isAssignableTo(targetType) {
-        return (reflection_1.isVoidType(targetType) ||
-            reflection_1.isDynamicType(targetType));
+        return ((0, reflection_1.isVoidType)(targetType) ||
+            (0, reflection_1.isDynamicType)(targetType));
     }
     isConvertibleTo(targetType) {
         return this.isAssignableTo(targetType);
     }
     toString() {
-        return 'void';
+        var _a;
+        return (_a = this.typeText) !== null && _a !== void 0 ? _a : 'void';
     }
     toTypeString() {
         return this.toString();
     }
     equals(targetType) {
-        return reflection_1.isVoidType(targetType);
+        return (0, reflection_1.isVoidType)(targetType);
     }
 }
 exports.VoidType = VoidType;

package/dist/types/VoidType.js.map

@@ -1 +1 @@
-{"version":3,"file":"VoidType.js","sourceRoot":"","sources":["../../src/types/VoidType.ts"],"names":[],"mappings":";;;AAAA,uDAAmE;AAGnE,MAAa,QAAQ;IACV,cAAc,CAAC,UAAmB;QACrC,OAAO,CACH,uBAAU,CAAC,UAAU,CAAC;YACtB,0BAAa,CAAC,UAAU,CAAC,CAC5B,CAAC;IACN,CAAC;IAEM,eAAe,CAAC,UAAmB;QACtC,OAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAEM,QAAQ;QACX,OAAO,MAAM,CAAC;IAClB,CAAC;IAGM,YAAY;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAEM,MAAM,CAAC,UAAmB;QAC7B,OAAO,uBAAU,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;CACJ;AAxBD,4BAwBC"}
+{"version":3,"file":"VoidType.js","sourceRoot":"","sources":["../../src/types/VoidType.ts"],"names":[],"mappings":";;;AAAA,uDAAmE;AAGnE,MAAa,QAAQ;IACjB,YACW,QAAiB;QAAjB,aAAQ,GAAR,QAAQ,CAAS;IACxB,CAAC;IAEE,cAAc,CAAC,UAAmB;QACrC,OAAO,CACH,IAAA,uBAAU,EAAC,UAAU,CAAC;YACtB,IAAA,0BAAa,EAAC,UAAU,CAAC,CAC5B,CAAC;IACN,CAAC;IAEM,eAAe,CAAC,UAAmB;QACtC,OAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAEM,QAAQ;;QACX,OAAO,MAAA,IAAI,CAAC,QAAQ,mCAAI,MAAM,CAAC;IACnC,CAAC;IAEM,YAAY;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAEM,MAAM,CAAC,UAAmB;QAC7B,OAAO,IAAA,uBAAU,EAAC,UAAU,CAAC,CAAC;IAClC,CAAC;CACJ;AA3BD,4BA2BC"}

package/dist/types/VoidType.spec.js

@@ -5,8 +5,8 @@ const DynamicType_1 = require("./DynamicType");
 const VoidType_1 = require("./VoidType");
 describe('VoidType', () => {
     it('is equivalent to dynamic types', () => {
-        chai_1.expect(new VoidType_1.VoidType().isAssignableTo(new VoidType_1.VoidType())).to.be.true;
-        chai_1.expect(new VoidType_1.VoidType().isAssignableTo(new DynamicType_1.DynamicType())).to.be.true;
+        (0, chai_1.expect)(new VoidType_1.VoidType().isAssignableTo(new VoidType_1.VoidType())).to.be.true;
+        (0, chai_1.expect)(new VoidType_1.VoidType().isAssignableTo(new DynamicType_1.DynamicType())).to.be.true;
     });
 });
 //# sourceMappingURL=VoidType.spec.js.map

package/dist/types/VoidType.spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"VoidType.spec.js","sourceRoot":"","sources":["../../src/types/VoidType.spec.ts"],"names":[],"mappings":";;AAAA,+BAA8B;AAE9B,+CAA4C;AAC5C,yCAAsC;AAEtC,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE;IACtB,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QACtC,aAAM,CAAC,IAAI,mBAAQ,EAAE,CAAC,cAAc,CAAC,IAAI,mBAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;QACjE,aAAM,CAAC,IAAI,mBAAQ,EAAE,CAAC,cAAc,CAAC,IAAI,yBAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;IACxE,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}
+{"version":3,"file":"VoidType.spec.js","sourceRoot":"","sources":["../../src/types/VoidType.spec.ts"],"names":[],"mappings":";;AAAA,+BAA8B;AAE9B,+CAA4C;AAC5C,yCAAsC;AAEtC,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE;IACtB,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QACtC,IAAA,aAAM,EAAC,IAAI,mBAAQ,EAAE,CAAC,cAAc,CAAC,IAAI,mBAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;QACjE,IAAA,aAAM,EAAC,IAAI,mBAAQ,EAAE,CAAC,cAAc,CAAC,IAAI,yBAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;IACxE,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}

package/dist/types/helpers.d.ts

@@ -0,0 +1,42 @@
+import type { CallExpression, DottedGetExpression, FunctionExpression, NewExpression, VariableExpression } from '../parser/Expression';
+import type { BscType } from './BscType';
+/**
+ * Gets the return type of a function, taking into account that the function may not have been declared yet
+ * If the callee already exists in symbol table, use that return type
+ * otherwise, make a lazy type which will not compute its type until the file is done parsing
+ *
+ * @param call the Expression to process
+ * @param functionExpression the wrapping function expression
+ * @return the best guess type of that expression
+ */
+export declare function getTypeFromCallExpression(call: CallExpression, functionExpression: FunctionExpression): BscType;
+/**
+ * Gets the type of a variable
+ * if it already exists in symbol table, use that type
+ * otherwise defer the type until first read, which will allow us to derive types from variables defined after this one (like from a loop perhaps)
+ *
+ * @param variable the Expression to process
+ * @param functionExpression the wrapping function expression
+ * @return the best guess type of that expression
+ */
+export declare function getTypeFromVariableExpression(variable: VariableExpression, functionExpression: FunctionExpression): BscType;
+/**
+ * Gets the type of a variable
+ * if it already exists in symbol table, use that type
+ * otherwise defer the type until first read, which will allow us to derive types from variables defined after this one (like from a loop perhaps)
+ *
+ * @param newExp the Expression to process
+ * @param functionExpression the wrapping function expression
+ * @return the best guess type of that expression
+ */
+export declare function getTypeFromNewExpression(newExp: NewExpression, functionExpression: FunctionExpression): BscType;
+/**
+ * Gets the type of a variable
+ * if it already exists in symbol table, use that type
+ * otherwise defer the type until first read, which will allow us to derive types from variables defined after this one (like from a loop perhaps)
+ *
+ * @param variable the Expression to process
+ * @param functionExpression the wrapping function expression
+ * @return the best guess type of that expression
+ */
+export declare function getTypeFromDottedGetExpression(expr: DottedGetExpression, functionExpression: FunctionExpression): BscType;

package/dist/types/helpers.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeFromDottedGetExpression = exports.getTypeFromNewExpression = exports.getTypeFromVariableExpression = exports.getTypeFromCallExpression = void 0;
+const reflection_1 = require("../astUtils/reflection");
+const LazyType_1 = require("./LazyType");
+const UninitializedType_1 = require("./UninitializedType");
+const Parser_1 = require("../parser/Parser");
+const CustomType_1 = require("./CustomType");
+const DynamicType_1 = require("./DynamicType");
+/**
+ * Gets the return type of a function, taking into account that the function may not have been declared yet
+ * If the callee already exists in symbol table, use that return type
+ * otherwise, make a lazy type which will not compute its type until the file is done parsing
+ *
+ * @param call the Expression to process
+ * @param functionExpression the wrapping function expression
+ * @return the best guess type of that expression
+ */
+function getTypeFromCallExpression(call, functionExpression) {
+    let calleeName = call.callee.name;
+    if (calleeName) {
+        const currentKnownType = functionExpression.symbolTable.getSymbolType(calleeName.text.toLowerCase());
+        if ((0, reflection_1.isTypedFunctionType)(currentKnownType)) {
+            return currentKnownType.returnType;
+        }
+        if (currentKnownType) {
+            // this will probably only happen if a functionName has been assigned to something else previously?
+            return currentKnownType;
+        }
+        return new LazyType_1.LazyType((context) => {
+            var _a;
+            let futureType;
+            if ((0, reflection_1.isBrsFile)(context === null || context === void 0 ? void 0 : context.file)) {
+                const file = context.file;
+                futureType = (_a = file.getSymbolTypeFromToken(calleeName, functionExpression, context.scope)) === null || _a === void 0 ? void 0 : _a.type;
+            }
+            else {
+                // Give best guess if there is no file context
+                futureType = functionExpression.symbolTable.getSymbolType(calleeName.text);
+            }
+            if ((0, reflection_1.isTypedFunctionType)(futureType)) {
+                return futureType.returnType;
+            }
+            return futureType;
+        });
+    }
+    else {
+        //return dynamic if we can't figure out the type
+        return new DynamicType_1.DynamicType();
+    }
+}
+exports.getTypeFromCallExpression = getTypeFromCallExpression;
+/**
+ * Gets the type of a variable
+ * if it already exists in symbol table, use that type
+ * otherwise defer the type until first read, which will allow us to derive types from variables defined after this one (like from a loop perhaps)
+ *
+ * @param variable the Expression to process
+ * @param functionExpression the wrapping function expression
+ * @return the best guess type of that expression
+ */
+function getTypeFromVariableExpression(variable, functionExpression) {
+    let variableName = variable.name.text.toLowerCase();
+    const currentKnownType = functionExpression.symbolTable.getSymbolType(variableName);
+    if ((0, reflection_1.isPrimitiveType)(currentKnownType) || (0, reflection_1.isArrayType)(currentKnownType)) {
+        // for "contextless" types, eg. myVar = 3.14
+        return currentKnownType;
+    }
+    return resolveLazyType(variable.name, functionExpression);
+}
+exports.getTypeFromVariableExpression = getTypeFromVariableExpression;
+/**
+ * Gets the type of a variable
+ * if it already exists in symbol table, use that type
+ * otherwise defer the type until first read, which will allow us to derive types from variables defined after this one (like from a loop perhaps)
+ *
+ * @param newExp the Expression to process
+ * @param functionExpression the wrapping function expression
+ * @return the best guess type of that expression
+ */
+function getTypeFromNewExpression(newExp, functionExpression) {
+    let className = newExp.className.getName(Parser_1.ParseMode.BrighterScript);
+    return new LazyType_1.LazyType((context) => {
+        var _a, _b, _c;
+        return new CustomType_1.CustomType(className, (_c = (_a = context === null || context === void 0 ? void 0 : context.scope) === null || _a === void 0 ? void 0 : _a.getClass(className, (_b = functionExpression.namespaceName) === null || _b === void 0 ? void 0 : _b.getName())) === null || _c === void 0 ? void 0 : _c.memberTable);
+    });
+}
+exports.getTypeFromNewExpression = getTypeFromNewExpression;
+function resolveLazyType(currentToken, functionExpression) {
+    return new LazyType_1.LazyType((context) => {
+        var _a, _b;
+        let futureType;
+        if ((0, reflection_1.isBrsFile)(context === null || context === void 0 ? void 0 : context.file)) {
+            const file = context.file;
+            futureType = (_a = file.getSymbolTypeFromToken(currentToken, functionExpression, context.scope)) === null || _a === void 0 ? void 0 : _a.type;
+        }
+        else {
+            // Give best guess if there is no file context
+            futureType = (_b = functionExpression.symbolTable.getSymbolType(currentToken.text)) !== null && _b !== void 0 ? _b : new UninitializedType_1.UninitializedType();
+        }
+        return futureType;
+    });
+}
+/**
+ * Gets the type of a variable
+ * if it already exists in symbol table, use that type
+ * otherwise defer the type until first read, which will allow us to derive types from variables defined after this one (like from a loop perhaps)
+ *
+ * @param variable the Expression to process
+ * @param functionExpression the wrapping function expression
+ * @return the best guess type of that expression
+ */
+function getTypeFromDottedGetExpression(expr, functionExpression) {
+    const currentToken = (0, reflection_1.isCallExpression)(expr) ? (expr.callee).name : expr.name;
+    return resolveLazyType(currentToken, functionExpression);
+}
+exports.getTypeFromDottedGetExpression = getTypeFromDottedGetExpression;
+//# sourceMappingURL=helpers.js.map

package/dist/types/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/types/helpers.ts"],"names":[],"mappings":"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"}

package/dist/util.d.ts

@@ -1,23 +1,21 @@
-import * as rokuDeploy from 'roku-deploy';
 import type { Diagnostic, Position, Range } from 'vscode-languageserver';
 import type { BsConfig } from './BsConfig';
-import type { CallableContainer, BsDiagnostic, FileReference, CallableContainerMap, CompilerPlugin, ExpressionInfo, FunctionCall } from './interfaces';
+import type { CallableContainer, BsDiagnostic, FileReference, CallableContainerMap, CompilerPlugin, ExpressionInfo, FunctionCall, CallableParam, TranspileResult } from './interfaces';
 import { BooleanType } from './types/BooleanType';
 import { DoubleType } from './types/DoubleType';
 import { DynamicType } from './types/DynamicType';
 import { FloatType } from './types/FloatType';
-import { FunctionType } from './types/FunctionType';
 import { IntegerType } from './types/IntegerType';
 import { InvalidType } from './types/InvalidType';
 import { LongIntegerType } from './types/LongIntegerType';
-import { ObjectType } from './types/ObjectType';
 import { StringType } from './types/StringType';
 import { VoidType } from './types/VoidType';
-import type { DottedGetExpression, Expression, VariableExpression } from './parser/Expression';
-import type { Token } from './lexer';
-import { CustomType } from './types/CustomType';
+import type { DottedGetExpression, Expression, NamespacedVariableNameExpression, VariableExpression } from './parser/Expression';
+import type { Locatable, Token } from './lexer/Token';
 import { SourceNode } from 'source-map';
-import type { SGAttribute } from './parser/SGTypes';
+import { SGAttribute } from './parser/SGTypes';
+import type { BscType } from './types/BscType';
+import { FunctionType } from './types/FunctionType';
 export declare class Util {
     clearConsole(): void;
     /**
@@ -62,12 +60,11 @@ export declare class Util {
      */
     loadConfigFile(configFilePath: string, parentProjectPaths?: string[], cwd?: string): BsConfig;
     /**
-     * Relative paths to scripts in plugins should be resolved relatively to the bsconfig file
-     * and de-duplicated
-     * @param config Parsed configuration
-     * @param configFilePath Path of the configuration file
+     * Convert relative paths to absolute paths, relative to the given directory. Also de-dupes the paths. Modifies the array in-place
+     * @param paths the list of paths to be resolved and deduped
+     * @param relativeDir the path to the folder where the paths should be resolved relative to. This should be an absolute path
      */
-    resolvePluginPaths(config: BsConfig, configFilePath: string): void;
+    resolvePathsRelativeTo(collection: any, key: string, relativeDir: string): void;
     /**
      * Do work within the scope of a changed current working directory
      * @param targetCwd
@@ -116,10 +113,10 @@ export declare class Util {
     getPkgPathFromTarget(sourcePkgPath: string, targetPath: string): string;
     /**
      * Compute the relative path from the source file to the target file
-     * @param pkgSourcePathAbsolute  - the absolute path to the source relative to the package location
-     * @param pkgTargetPathAbsolute  - the absolute path ro the target relative to the package location
+     * @param pkgSrcPath  - the absolute path to the source, where cwd is the package location
+     * @param pkgTargetPath  - the absolute path to the target, where cwd is the package location
      */
-    getRelativePath(pkgSourcePathAbsolute: string, pkgTargetPathAbsolute: string): string;
+    getRelativePath(pkgSrcPath: string, pkgTargetPath: string): string;
     /**
      * Walks left in a DottedGetExpression and returns a VariableExpression if found, or undefined if not found
      */
@@ -171,7 +168,7 @@ export declare class Util {
     /**
      * Get paths to all files on disc that match this project's source list
      */
-    getFilePaths(options: BsConfig): Promise<rokuDeploy.StandardizedFileEntry[]>;
+    getFilePaths(options: BsConfig): Promise<import("roku-deploy").StandardizedFileEntry[]>;
     /**
      * Given a path to a brs file, compute the path to a theoretical d.bs file.
      * Only `.brs` files can have a typedef, so return undefined for everything else
@@ -258,6 +255,13 @@ export declare class Util {
      * Create a `Range` from two `Position`s
      */
     createRangeFromPositions(startPosition: Position, endPosition: Position): Range;
+    /**
+     * Given a list of ranges, create a range that starts with the first non-null lefthand range, and ends with the first non-null
+     * righthand range. Returns undefined if none of the items have a range.
+     */
+    createBoundingRange(...locatables: Array<{
+        range?: Range;
+    }>): Range;
     /**
      * Create a `Position` object. Prefer this over `Position.create` for performance reasons
      */
@@ -272,7 +276,7 @@ export declare class Util {
     /**
      * Convert a token into a BscType
      */
-    tokenToBscType(token: Token, allowCustomType?: boolean): DynamicType | ObjectType | CustomType | BooleanType | DoubleType | FloatType | FunctionType | IntegerType | InvalidType | LongIntegerType | StringType | VoidType;
+    tokenToBscType(token: Token, allowBrighterscriptTypes?: boolean, currentNamespaceName?: NamespacedVariableNameExpression): DynamicType | BscType | FloatType | IntegerType | DoubleType | LongIntegerType | StringType | BooleanType | FunctionType | InvalidType | VoidType;
     /**
      * Get the extension for the given file path. Basically the part after the final dot, except for
      * `d.bs` which is treated as single extension
@@ -294,14 +298,26 @@ export declare class Util {
      */
     simpleMap(source: string, src: string): SourceNode;
     /**
-     * Creates a new SGAttribute object, but keeps the existing Range references (since those shouldn't ever get changed directly)
+     * Creates a new SGAttribute object, but keeps the existing Range references (since those should be immutable)
      */
     cloneSGAttribute(attr: SGAttribute, value: string): SGAttribute;
+    /**
+     * Shorthand for creating a new source node
+     */
+    sourceNode(source: string, locatable: {
+        range: Range;
+    }, code: string | SourceNode | TranspileResult): SourceNode | undefined;
     /**
      * Remove leading simple protocols from a path (if present)
      */
     removeProtocol(pkgPath: string): string;
+    /**
+     * Converts a path into a standardized format (drive letter to lower, remove extra slashes, use single slash type, resolve relative parts, etc...)
+     */
     standardizePath(thePath: string): string;
+    /**
+     * Copy the version of bslib from local node_modules to the staging folder
+     */
     copyBslibToStaging(stagingDir: string): Promise<void>;
     /**
      * Given a Diagnostic or BsDiagnostic, return a copy of the diagnostic
@@ -318,11 +334,60 @@ export declare class Util {
         source: string;
     };
     /**
-     * Finds the array of callables from a container map, taking into account the function from which it was called
+     * Gets the minimum and maximum number of allowed params
+     * @param params The list of callable parameters to check
+     * @returns the minimum and maximum number of allowed params
+     */
+    getMinMaxParamCount(params: CallableParam[]): MinMax;
+    /**
+     * Gets the minimum and maximum number of allowed params for ALL functions with the name of the function call
+     * @param callablesByLowerName The map of callable containers
+     * @param expCall function call expression to use for the name
+     * @returns the minimum and maximum number of allowed params
+     */
+    getMinMaxParamCountByFunctionCall(callablesByLowerName: CallableContainerMap, expCall: FunctionCall): MinMax;
+    /**
+     * Finds the array of callables from a container map, based on the name of the function call
      * If the callable was called in a function in a namespace, functions in that namespace are preferred
+     * @param callablesByLowerName The map of callable containers
+     * @param expCall function call expression to use for the name
      * @return an array with callable containers - could be empty if nothing was found
      */
-    getCallableContainersFromContainerMapByFunctionCall(callablesByLowerName: CallableContainerMap, expCall: FunctionCall): CallableContainer[];
+    getCallableContainersByName(callablesByLowerName: CallableContainerMap, expCall: FunctionCall): CallableContainer[];
+    /**
+     * Sort an array of objects that have a Range
+     */
+    sortByRange(locatables: Locatable[]): Locatable[];
+    /**
+     * Split the given text and return ranges for each chunk.
+     * Only works for single-line strings
+     */
+    splitGetRange(separator: string, text: string, range: Range): {
+        text: string;
+        range: Range;
+    }[];
+    mdFence(code: string, language?: string): string;
+    /**
+     * Finds a callable from a container map based on the name AND number of arguments
+     * If the callable was called in a function in a namespace, functions in that namespace are preferred
+     * The first callable that matches the name AND will accept the number of arguments given is returned
+     * @return a callable containers that matches the call
+     */
+    getCallableContainerByFunctionCall(callablesByLowerName: CallableContainerMap, expCall: FunctionCall): CallableContainer;
+    /**
+     * Gets each part of the dotted get.
+     * @param expression
+     * @returns an array of the parts of the dotted get. If not fully a dotted get, then returns undefined
+     */
+    getAllDottedGetParts(expression: Expression): string[] | undefined;
+    /**
+     * Returns an integer if valid, or undefined. Eliminates checking for NaN
+     */
+    parseInt(value: any): number;
+    /**
+     * Converts a range to a string in the format 1:2-3:4
+     */
+    rangeToString(range: Range): string;
 }
 /**
  * A tagged template literal function for standardizing the path. This has to be defined as standalone function since it's a tagged template literal function,
@@ -331,3 +396,8 @@ export declare class Util {
 export declare function standardizePath(stringParts: any, ...expressions: any[]): string;
 export declare let util: Util;
 export default util;
+export interface MinMax {
+    min: number;
+    max: number;
+}
+export declare const MAX_PARAM_COUNT = 32;