brighterscript 1.0.0-alpha.2 → 1.0.0-alpha.20

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,22 @@
 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 +61,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
@@ -258,6 +256,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 +277,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 +299,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 +335,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 +397,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;