brighterscript 0.41.2 → 1.0.0-alpha.12

package/dist/types/VoidType.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VoidType = void 0;
-const DynamicType_1 = require("./DynamicType");
+const reflection_1 = require("../astUtils/reflection");
 class VoidType {
     isAssignableTo(targetType) {
-        return (targetType instanceof VoidType ||
-            targetType instanceof DynamicType_1.DynamicType);
+        return ((0, reflection_1.isVoidType)(targetType) ||
+            (0, reflection_1.isDynamicType)(targetType));
     }
     isConvertibleTo(targetType) {
         return this.isAssignableTo(targetType);
@@ -16,6 +16,9 @@ class VoidType {
     toTypeString() {
         return this.toString();
     }
+    equals(targetType) {
+        return (0, reflection_1.isVoidType)(targetType);
+    }
 }
 exports.VoidType = VoidType;
 //# sourceMappingURL=VoidType.js.map

package/dist/types/VoidType.js.map

@@ -1 +1 @@
-{"version":3,"file":"VoidType.js","sourceRoot":"","sources":["../../src/types/VoidType.ts"],"names":[],"mappings":";;;AACA,+CAA4C;AAE5C,MAAa,QAAQ;IACV,cAAc,CAAC,UAAmB;QACrC,OAAO,CACH,UAAU,YAAY,QAAQ;YAC9B,UAAU,YAAY,yBAAW,CACpC,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;CACJ;AApBD,4BAoBC"}
+{"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,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,MAAM,CAAC;IAClB,CAAC;IAGM,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;AAxBD,4BAwBC"}

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,113 @@
+"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");
+/**
+ * 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.isFunctionType)(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.isFunctionType)(futureType)) {
+                return futureType.returnType;
+            }
+            return futureType;
+        });
+    }
+}
+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)) {
+        // 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,7 +1,7 @@
 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 } 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';
@@ -13,11 +13,11 @@ 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 { DottedGetExpression, Expression, NamespacedVariableNameExpression, VariableExpression } from './parser/Expression';
 import type { Locatable, Token } from './lexer';
-import { CustomType } from './types/CustomType';
 import { SourceNode } from 'source-map';
-import type { SGAttribute } from './parser/SGTypes';
+import { SGAttribute } from './parser/SGTypes';
+import { LazyType } from './types/LazyType';
 export declare class Util {
     clearConsole(): void;
     /**
@@ -37,7 +37,11 @@ export declare class Util {
     /**
      * Given a pkg path of any kind, transform it to a roku-specific pkg path (i.e. "pkg:/some/path.brs")
      */
-    getRokuPkgPath(pkgPath: string): string;
+    sanitizePkgPath(pkgPath: string): string;
+    /**
+     * Determine if the given path starts with a protocol
+     */
+    startsWithProtocol(path: string): boolean;
     /**
      * Given a path to a file/directory, replace all path separators with the current system's version.
      * @param filePath
@@ -105,12 +109,11 @@ export declare class Util {
      */
     getLines(text: string): string[];
     /**
-     * Given an absolute path to a source file, and a target path,
-     * compute the pkg path for the target relative to the source file's location
-     * @param containingFilePathAbsolute
-     * @param targetPath
+     * Compute the pkg path for the target relative to the source file's location
+     * @param sourcePkgPath The pkgPath of the file that contains the target path
+     * @param targetPath a full pkgPath, or a path relative to the containing file
      */
-    getPkgPathFromTarget(containingFilePathAbsolute: string, targetPath: string): string;
+    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
@@ -157,8 +160,9 @@ export declare class Util {
     areArraysEqual(arr1: any[], arr2: any[]): boolean;
     /**
      * Given a file path, convert it to a URI string
+     * @param srcPath The absolute path to the source file on disk
      */
-    pathToUri(pathAbsolute: string): string;
+    pathToUri(srcPath: string): string;
     /**
      * Get the outDir from options, taking into account cwd and absolute outFile paths
      * @param options
@@ -170,7 +174,8 @@ export declare class Util {
     getFilePaths(options: BsConfig): Promise<rokuDeploy.StandardizedFileEntry[]>;
     /**
      * Given a path to a brs file, compute the path to a theoretical d.bs file.
-     * Only `.brs` files can have typedef path, so return undefined for everything else
+     * Only `.brs` files can have a typedef, so return undefined for everything else
+     * @param brsSrcPath The absolute path to the .brs source file on disk
      */
     getTypedefPath(brsSrcPath: string): string;
     /**
@@ -253,6 +258,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
      */
@@ -267,7 +279,7 @@ export declare class Util {
     /**
      * Convert a token into a BscType
      */
-    tokenToBscType(token: Token, allowCustomType?: boolean): DynamicType | BooleanType | LongIntegerType | IntegerType | FloatType | DoubleType | FunctionType | InvalidType | ObjectType | StringType | VoidType | CustomType;
+    tokenToBscType(token: Token, allowCustomType?: boolean, currentNamespaceName?: NamespacedVariableNameExpression): DynamicType | FloatType | FunctionType | IntegerType | LongIntegerType | StringType | BooleanType | LazyType | ObjectType | DoubleType | 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
@@ -289,12 +301,20 @@ 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;
     /**
-     * Copy the version of bslib from local node_modules to the staging folder
+     * 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;
+    standardizePath(thePath: string): string;
     copyBslibToStaging(stagingDir: string): Promise<void>;
     /**
      * Given a Diagnostic or BsDiagnostic, return a copy of the diagnostic
@@ -310,6 +330,27 @@ export declare class Util {
         code: string | number;
         source: string;
     };
+    /**
+     * 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
+     */
+    getCallableContainersByName(callablesByLowerName: CallableContainerMap, expCall: FunctionCall): CallableContainer[];
     /**
      * Sort an array of objects that have a Range
      */
@@ -322,6 +363,13 @@ export declare class Util {
         text: string;
         range: Range;
     }[];
+    /**
+    * 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;
 }
 /**
  * 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,
@@ -330,3 +378,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;