brighterscript 1.0.0-alpha.22 → 1.0.0-alpha.24

package/dist/Scope.d.ts

@@ -1,16 +1,15 @@
-import type { CompletionItem, Position, Range } from 'vscode-languageserver';
-import { Location } from 'vscode-languageserver';
+import type { CompletionItem, Position, Range, Location } from 'vscode-languageserver';
 import type { CallableContainer, BsDiagnostic, BscFile, CallableContainerMap, FileLink, InheritableStatement, InheritableType, NamedTypeStatement } from './interfaces';
 import type { Program } from './Program';
-import type { NamespaceStatement, Statement, FunctionStatement, ClassStatement, EnumStatement, InterfaceStatement } from './parser/Statement';
+import type { NamespaceStatement, Statement, FunctionStatement, ClassStatement, EnumStatement, InterfaceStatement, EnumMemberStatement, ConstStatement } from './parser/Statement';
 import type { FunctionExpression, NewExpression } from './parser/Expression';
 import { ParseMode } from './parser/Parser';
 import { Cache } from './Cache';
 import type { BrsFile, TokenSymbolLookup } from './files/BrsFile';
 import type { DependencyGraph, DependencyChangedEvent } from './DependencyGraph';
 import { SymbolTable } from './SymbolTable';
-import type { BscType, TypeContext } from './types/BscType';
 import type { Token } from './lexer/Token';
+import type { BscType, TypeContext } from './types/BscType';
 /**
  * A class to keep track of all declarations within a given scope (like source scope, component scope)
  */
@@ -81,10 +80,10 @@ export declare class Scope {
      */
     getEnumFileLink(enumName: string, containingNamespace?: string): FileLink<EnumStatement>;
     /**
-   * Get a Named Type (e.g. Class, Interface, Enum) and its containing file by the name
-   * @param name - The name of the type, including the namespace of the class/interface/enum, etc. if possible
-   * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find a class)
-   */
+     * Get a Named Type (e.g. Class, Interface, Enum) and its containing file by the name
+     * @param name - The name of the type, including the namespace of the class/interface/enum, etc. if possible
+     * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find a class)
+     */
     getNamedTypeFileLink(name: string, containingNamespace?: string): FileLink<NamedTypeStatement>;
     /**
      * Get a InheritableStatement and its containing file by the name of the interface or class
@@ -97,6 +96,12 @@ export declare class Scope {
      * @param klass - The class to get the parent of, if possible
      */
     getParentClass(klass: ClassStatement): ClassStatement;
+    /**
+     * Get a constant and its containing file by the constant name
+     * @param constName - The constant name, including the namespace of the constant if possible
+     * @param containingNamespace - The namespace used to resolve relative constant names. (i.e. the namespace around the current statement trying to find a constant)
+     */
+    getConstFileLink(constName: string, containingNamespace?: string): FileLink<ConstStatement>;
     /**
      * Gets the parent interface of the given interface
      * @param iface - The interface to get the parent of, if possible
@@ -107,6 +112,7 @@ export declare class Scope {
     * @param stmt - The class or interface to get the parent of, if possible
     */
     getParentStatement(stmt: InheritableStatement): InheritableStatement;
+    getEnumMemberMap(): Map<string, EnumMemberStatement>;
     /**
     * Tests if a class exists with the specified name
     * @param className - the all-lower-case namespace-included class name
@@ -148,6 +154,11 @@ export declare class Scope {
      * The key is stored in lower case
      */
     getEnumMap(): Map<string, FileLink<EnumStatement>>;
+    /**
+     * A dictionary of all constants in this scope. This includes namespaced constants always with their full name.
+     * The key is stored in lower case
+     */
+    getConstMap(): Map<string, FileLink<ConstStatement>>;
     /**
      * The list of diagnostics found specifically for this scope. Individual file diagnostics are stored on the files themselves.
      */
@@ -233,13 +244,13 @@ export declare class Scope {
     protected logDebug(...args: any[]): void;
     private _debugLogComponentName;
     validate(): void;
+    getCallableContainerMap(): CallableContainerMap;
     protected _validate(callableContainerMap: CallableContainerMap): void;
     /**
      * Mark this scope as invalid, which means its `validate()` function needs to be called again before use.
      */
     invalidate(): void;
-    get symbolTable(): SymbolTable;
-    private _symbolTable;
+    get symbolTable(): any;
     protected _memberTable: SymbolTable;
     get memberTable(): SymbolTable;
     protected clearSymbolTable(): void;
@@ -259,11 +270,6 @@ export declare class Scope {
     * Find function parameters and function return types that are neither built-in types or known Class references
     */
     private diagnosticDetectInvalidFunctionExpressionTypes;
-    /**
-    * Find functions with either the wrong type of parameters, or the wrong number of parameters
-    */
-    private diagnosticDetectInvalidFunctionCalls;
-    private addMismatchParamCountDiagnostic;
     getNewExpressions(): AugmentedNewExpression[];
     private validateClasses;
     /**
@@ -324,8 +330,10 @@ export interface NamespaceContainer {
     lastPartName: string;
     statements: Statement[];
     classStatements: Record<string, ClassStatement>;
+    interfaceStatements: Record<string, InterfaceStatement>;
     functionStatements: Record<string, FunctionStatement>;
     enumStatements: Map<string, EnumStatement>;
+    constStatements: Map<string, ConstStatement>;
     namespaces: Map<string, NamespaceContainer>;
     symbolTable: SymbolTable;
 }

package/dist/Scope.js

@@ -16,7 +16,6 @@ const SymbolTable_1 = require("./SymbolTable");
 const BscType_1 = require("./types/BscType");
 const DynamicType_1 = require("./types/DynamicType");
 const ObjectType_1 = require("./types/ObjectType");
-const UninitializedType_1 = require("./types/UninitializedType");
 /**
  * A class to keep track of all declarations within a given scope (like source scope, component scope)
  */
@@ -135,10 +134,10 @@ class Scope {
         return enumeration;
     }
     /**
-   * Get a Named Type (e.g. Class, Interface, Enum) and its containing file by the name
-   * @param name - The name of the type, including the namespace of the class/interface/enum, etc. if possible
-   * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find a class)
-   */
+     * Get a Named Type (e.g. Class, Interface, Enum) and its containing file by the name
+     * @param name - The name of the type, including the namespace of the class/interface/enum, etc. if possible
+     * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find a class)
+     */
     getNamedTypeFileLink(name, containingNamespace) {
         return this.getInheritableFileLink(name, containingNamespace) || this.getEnumFileLink(name, containingNamespace);
     }
@@ -165,6 +164,21 @@ class Scope {
             }
         }
     }
+    /**
+     * Get a constant and its containing file by the constant name
+     * @param constName - The constant name, including the namespace of the constant if possible
+     * @param containingNamespace - The namespace used to resolve relative constant names. (i.e. the namespace around the current statement trying to find a constant)
+     */
+    getConstFileLink(constName, containingNamespace) {
+        const lowerName = constName === null || constName === void 0 ? void 0 : constName.toLowerCase();
+        const constMap = this.getConstMap();
+        let result = constMap.get(util_1.util.getFullyQualifiedClassName(lowerName, containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase()));
+        //if we couldn't find the constant by its full namespaced name, look for a global constant with that name
+        if (!result) {
+            result = constMap.get(lowerName);
+        }
+        return result;
+    }
     /**
      * Gets the parent interface of the given interface
      * @param iface - The interface to get the parent of, if possible
@@ -192,6 +206,22 @@ class Scope {
             return this.getParentClass(stmt);
         }
     }
+    /*
+    * Get a map of all enums by their member name.
+    * The keys are lower-case fully-qualified paths to the enum and its member. For example:
+    * namespace.enum.value
+    */
+    getEnumMemberMap() {
+        return this.cache.getOrAdd('enumMemberMap', () => {
+            const result = new Map();
+            for (const [key, eenum] of this.getEnumMap()) {
+                for (const member of eenum.item.getMembers()) {
+                    result.set(`${key}.${member.name.toLowerCase()}`, member);
+                }
+            }
+            return result;
+        });
+    }
     /**
     * Tests if a class exists with the specified name
     * @param className - the all-lower-case namespace-included class name
@@ -310,6 +340,25 @@ class Scope {
             return map;
         });
     }
+    /**
+     * A dictionary of all constants in this scope. This includes namespaced constants always with their full name.
+     * The key is stored in lower case
+     */
+    getConstMap() {
+        return this.cache.getOrAdd('constMap', () => {
+            const map = new Map();
+            this.enumerateBrsFiles((file) => {
+                for (let stmt of file.parser.references.constStatements) {
+                    const lowerEnumName = stmt.fullName.toLowerCase();
+                    //only track enums with a defined name (i.e. exclude nameless malformed enums)
+                    if (lowerEnumName) {
+                        map.set(lowerEnumName, { item: stmt, file: file });
+                    }
+                }
+            });
+            return map;
+        });
+    }
     onDependenciesChanged(event) {
         this.logDebug('invalidated because dependency graph said [', event.sourceKey, '] changed');
         this.invalidate();
@@ -523,9 +572,9 @@ class Scope {
     buildNamespaceLookup() {
         let namespaceLookup = new Map();
         this.enumerateBrsFiles((file) => {
-            for (let namespace of file.parser.references.namespaceStatements) {
+            for (let namespaceStatement of file.parser.references.namespaceStatements) {
                 //TODO should we handle non-brighterscript?
-                let name = namespace.nameExpression.getName(Parser_1.ParseMode.BrighterScript);
+                let name = namespaceStatement.nameExpression.getName(Parser_1.ParseMode.BrighterScript);
                 let nameParts = name.split('.');
                 let loopName = null;
                 //ensure each namespace section is represented in the results
@@ -537,33 +586,41 @@ class Scope {
                         namespaceLookup.set(lowerLoopName, {
                             file: file,
                             fullName: loopName,
-                            nameRange: namespace.nameExpression.range,
+                            nameRange: namespaceStatement.nameExpression.range,
                             lastPartName: part,
                             namespaces: new Map(),
                             classStatements: {},
                             functionStatements: {},
+                            interfaceStatements: {},
                             enumStatements: new Map(),
+                            constStatements: new Map(),
                             statements: [],
-                            symbolTable: new SymbolTable_1.SymbolTable(this.symbolTable)
+                            symbolTable: new SymbolTable_1.SymbolTable(this.symbolTable, `Namespace ${loopName}`)
                         });
                     }
                 }
                 let ns = namespaceLookup.get(name.toLowerCase());
-                ns.statements.push(...namespace.body.statements);
-                for (let statement of namespace.body.statements) {
+                ns.statements.push(...namespaceStatement.body.statements);
+                for (let statement of namespaceStatement.body.statements) {
                     if ((0, reflection_1.isClassStatement)(statement) && statement.name) {
                         ns.classStatements[statement.name.text.toLowerCase()] = statement;
                     }
+                    else if ((0, reflection_1.isInterfaceStatement)(statement) && statement.name) {
+                        ns.interfaceStatements[statement.name.text.toLowerCase()] = statement;
+                    }
                     else if ((0, reflection_1.isFunctionStatement)(statement) && statement.name) {
                         ns.functionStatements[statement.name.text.toLowerCase()] = statement;
                     }
                     else if ((0, reflection_1.isEnumStatement)(statement) && statement.fullName) {
                         ns.enumStatements.set(statement.fullName.toLowerCase(), statement);
                     }
+                    else if ((0, reflection_1.isConstStatement)(statement) && statement.fullName) {
+                        ns.constStatements.set(statement.fullName.toLowerCase(), statement);
+                    }
                 }
                 // Merges all the symbol tables of the namespace statements into the new symbol table created above.
                 // Set those symbol tables to have this new merged table as a parent
-                ns.symbolTable.mergeSymbolTable(namespace.symbolTable);
+                ns.symbolTable.mergeSymbolTable(namespaceStatement.symbolTable);
             }
             //associate child namespaces with their parents
             for (let [, ns] of namespaceLookup) {
@@ -599,27 +656,54 @@ class Scope {
             }
             //clear the scope's errors list (we will populate them from this method)
             this.diagnostics = [];
-            // link the symbol table
+            //Since statements from files are shared across multiple scopes, we need to link those statements to the current scope
             this.linkSymbolTable();
-            let callables = this.getAllCallables();
-            //sort the callables by filepath and then method name, so the errors will be consistent
-            callables = callables.sort((a, b) => {
-                return (
-                //sort by path
-                a.callable.file.srcPath.localeCompare(b.callable.file.srcPath) ||
-                    //then sort by method name
-                    a.callable.name.localeCompare(b.callable.name));
+            this.program.plugins.emit('beforeScopeValidate', {
+                program: this.program,
+                scope: this
             });
-            //get a list of all callables, indexed by their lower case names
-            let callableContainerMap = util_1.util.getCallableContainersByLowerName(callables);
             this.program.plugins.emit('onScopeValidate', {
                 program: this.program,
                 scope: this
             });
-            this._validate(callableContainerMap);
-            // unlink the symbol table so it can't be accessed from the wrong scope
+            this._validate(this.getCallableContainerMap());
+            this.program.plugins.emit('afterScopeValidate', {
+                program: this.program,
+                scope: this
+            });
+            //unlink all symbol tables from this scope (so they don't accidentally stick around)
             this.unlinkSymbolTable();
+            this.isValidated = true;
+        });
+    }
+    //Get a list of all callables, indexed by their lower case name
+    getCallableContainerMap() {
+        let callables = this.getAllCallables();
+        //sort the callables by filepath and then method name, so the errors will be consistent
+        // eslint-disable-next-line prefer-arrow-callback
+        callables = callables.sort((a, b) => {
+            const pathA = a.callable.file.srcPath;
+            const pathB = b.callable.file.srcPath;
+            //sort by path
+            if (pathA < pathB) {
+                return -1;
+            }
+            else if (pathA > pathB) {
+                return 1;
+            }
+            //sort by function name
+            const funcA = b.callable.name;
+            const funcB = b.callable.name;
+            if (funcA < funcB) {
+                return -1;
+            }
+            else if (funcA > funcB) {
+                return 1;
+            }
+            return 0;
         });
+        //get a list of all callables, indexed by their lower case names
+        return util_1.util.getCallableContainersByLowerName(callables);
     }
     _validate(callableContainerMap) {
         //find all duplicate function declarations
@@ -634,7 +718,6 @@ class Scope {
             this.diagnosticDetectFunctionCollisions(file);
             this.detectVariableNamespaceCollisions(file);
             this.diagnosticDetectInvalidFunctionExpressionTypes(file);
-            this.diagnosticDetectInvalidFunctionCalls(file, callableContainerMap);
         });
     }
     /**
@@ -648,17 +731,17 @@ class Scope {
         this.symbolCache.clear();
     }
     get symbolTable() {
-        var _a, _b;
-        if (!this._symbolTable) {
-            this._symbolTable = new SymbolTable_1.SymbolTable((_a = this.getParentScope()) === null || _a === void 0 ? void 0 : _a.symbolTable);
-            this._symbolTable.addSymbol('m', null, new ObjectType_1.ObjectType('object', this.memberTable));
+        return this.cache.getOrAdd('symbolTable', () => {
+            var _a, _b;
+            const result = new SymbolTable_1.SymbolTable((_a = this.getParentScope()) === null || _a === void 0 ? void 0 : _a.symbolTable, `Scope ${this.name}`);
+            result.addSymbol('m', null, new ObjectType_1.ObjectType('object', this.memberTable));
             for (let file of this.getOwnFiles()) {
                 if ((0, reflection_1.isBrsFile)(file)) {
-                    this._symbolTable.mergeSymbolTable((_b = file.parser) === null || _b === void 0 ? void 0 : _b.symbolTable);
+                    result.mergeSymbolTable((_b = file.parser) === null || _b === void 0 ? void 0 : _b.symbolTable);
                 }
             }
-        }
-        return this._symbolTable;
+            return result;
+        });
     }
     get memberTable() {
         var _a;
@@ -671,7 +754,7 @@ class Scope {
         return this._memberTable;
     }
     clearSymbolTable() {
-        this._symbolTable = null;
+        this.cache.delete('symbolTable');
         this._memberTable = null;
     }
     /**
@@ -683,11 +766,12 @@ class Scope {
         var _a, _b, _c;
         for (const file of this.getAllFiles()) {
             if ((0, reflection_1.isBrsFile)(file)) {
-                file.parser.symbolTable.setParent(this.symbolTable);
+                file.parser.symbolTable.pushParent(this.symbolTable);
+                //link each NamespaceStatement's SymbolTable with the aggregate NamespaceLookup SymbolTable
                 for (const namespace of file.parser.references.namespaceStatements) {
                     const namespaceNameLower = namespace.nameExpression.getName(Parser_1.ParseMode.BrighterScript).toLowerCase();
                     const namespaceSymbolTable = this.namespaceLookup.get(namespaceNameLower).symbolTable;
-                    namespace.symbolTable.setParent(namespaceSymbolTable);
+                    namespace.symbolTable.pushParent(namespaceSymbolTable);
                 }
                 //TODO TYPES: build symbol tables for dotted set assignments using actual values
                 // Currently this is prone to call-stack issues.
@@ -728,9 +812,9 @@ class Scope {
         var _a;
         for (let file of this.getOwnFiles()) {
             if ((0, reflection_1.isBrsFile)(file)) {
-                (_a = file.parser) === null || _a === void 0 ? void 0 : _a.symbolTable.setParent(null);
+                (_a = file.parser) === null || _a === void 0 ? void 0 : _a.symbolTable.popParent();
                 for (const namespace of file.parser.references.namespaceStatements) {
-                    namespace.symbolTable.setParent(null);
+                    namespace.symbolTable.popParent();
                 }
             }
         }
@@ -745,7 +829,7 @@ class Scope {
                 if (namespace) {
                     this.diagnostics.push(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.parameterMayNotHaveSameNameAsNamespace(param.name.text)), { range: param.name.range, relatedInformation: [{
                                 message: 'Namespace declared here',
-                                location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
+                                location: util_1.util.createLocation(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
                             }] }));
                 }
             }
@@ -757,7 +841,7 @@ class Scope {
             if (namespace) {
                 this.diagnostics.push(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.variableMayNotHaveSameNameAsNamespace(assignment.name.text)), { range: assignment.name.range, relatedInformation: [{
                             message: 'Namespace declared here',
-                            location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
+                            location: util_1.util.createLocation(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
                         }] }));
             }
         }
@@ -812,88 +896,6 @@ class Scope {
             }
         }
     }
-    /**
-    * Find functions with either the wrong type of parameters, or the wrong number of parameters
-    */
-    diagnosticDetectInvalidFunctionCalls(file, callableContainersByLowerName) {
-        var _a, _b, _c, _d;
-        if ((0, reflection_1.isBrsFile)(file)) {
-            for (let expCall of file.functionCalls) {
-                const symbolTypeInfo = file.getSymbolTypeFromToken(expCall.name, expCall.functionExpression, this);
-                let funcType = symbolTypeInfo.type;
-                if (!(0, reflection_1.isTypedFunctionType)(funcType) && !(0, reflection_1.isDynamicType)(funcType)) {
-                    // We don't know if this is a function. Try seeing if it is a global
-                    const callableContainer = util_1.util.getCallableContainerByFunctionCall(callableContainersByLowerName, expCall);
-                    if (callableContainer) {
-                        // We found a global callable with correct number of params - use that
-                        funcType = (_a = callableContainer.callable) === null || _a === void 0 ? void 0 : _a.type;
-                    }
-                    else {
-                        const allowedParamCount = util_1.util.getMinMaxParamCountByFunctionCall(callableContainersByLowerName, expCall);
-                        if (allowedParamCount) {
-                            // We found a global callable, but it needs a different number of args
-                            this.addMismatchParamCountDiagnostic(allowedParamCount, expCall, file);
-                            continue;
-                        }
-                    }
-                }
-                if ((0, reflection_1.isFunctionType)(funcType)) {
-                    // This is a generic function, and it is callable
-                }
-                else if ((0, reflection_1.isTypedFunctionType)(funcType)) {
-                    // Check for Argument count mismatch.
-                    //get min/max parameter count for callable
-                    let paramCount = util_1.util.getMinMaxParamCount(funcType.params);
-                    if (expCall.args.length > paramCount.max || expCall.args.length < paramCount.min) {
-                        this.addMismatchParamCountDiagnostic(paramCount, expCall, file);
-                    }
-                    // Check for Argument type mismatch.
-                    const paramTypeContext = { file: file, scope: this, position: (_b = expCall.functionExpression.range) === null || _b === void 0 ? void 0 : _b.start };
-                    const argTypeContext = { file: file, scope: this, position: (_c = expCall.range) === null || _c === void 0 ? void 0 : _c.start };
-                    for (let index = 0; index < funcType.params.length; index++) {
-                        const param = funcType.params[index];
-                        const arg = expCall.args[index];
-                        if (!arg) {
-                            // not enough args
-                            break;
-                        }
-                        let argType = (_d = arg.type) !== null && _d !== void 0 ? _d : new UninitializedType_1.UninitializedType();
-                        const paramType = (0, BscType_1.getTypeFromContext)(param.type, paramTypeContext);
-                        if (!paramType) {
-                            // other error - can not determine what type this parameter should be
-                            continue;
-                        }
-                        argType = (0, BscType_1.getTypeFromContext)(argType, argTypeContext);
-                        let assignable = argType === null || argType === void 0 ? void 0 : argType.isAssignableTo(paramType, argTypeContext);
-                        if (!assignable) {
-                            // TODO TYPES: perhaps this should be a strict mode setting?
-                            assignable = argType === null || argType === void 0 ? void 0 : argType.isConvertibleTo(paramType, argTypeContext);
-                        }
-                        if (!assignable) {
-                            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch(argType === null || argType === void 0 ? void 0 : argType.toString(argTypeContext), paramType.toString(paramTypeContext))), { range: arg === null || arg === void 0 ? void 0 : arg.range, file: file }));
-                        }
-                    }
-                }
-                else if ((0, reflection_1.isInvalidType)(symbolTypeInfo.type)) {
-                    // TODO TYPES: standard member functions like integer.ToStr() are not detectable yet.
-                }
-                else if ((0, reflection_1.isDynamicType)(symbolTypeInfo.type)) {
-                    // maybe this is a function? who knows
-                }
-                else {
-                    const functionNameText = symbolTypeInfo.expandedTokenText;
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callToUnknownFunction(functionNameText, this.name)), { range: expCall.nameRange, 
-                        //TODO detect end of expression call
-                        file: file }));
-                }
-            }
-        }
-    }
-    addMismatchParamCountDiagnostic(paramCount, expCall, file) {
-        const minMaxParamsText = paramCount.min === paramCount.max ? paramCount.max : `${paramCount.min}-${paramCount.max}`;
-        const expCallArgCount = expCall.args.length;
-        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchArgumentCount(minMaxParamsText, expCallArgCount)), { range: expCall.nameRange, file: file }));
-    }
     getNewExpressions() {
         let result = [];
         this.enumerateBrsFiles((file) => {