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

package/dist/Scope.d.ts

@@ -1,13 +1,16 @@
 import type { CompletionItem, Position, Range } from 'vscode-languageserver';
 import { Location } from 'vscode-languageserver';
-import type { CallableContainer, BsDiagnostic, BscFile, CallableContainerMap } from './interfaces';
-import type { FileLink, Program } from './Program';
-import type { NamespaceStatement, Statement, NewExpression, FunctionStatement, ClassStatement } from './parser';
-import { ParseMode } from './parser';
+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 { FunctionExpression, NewExpression } from './parser/Expression';
+import { ParseMode } from './parser/Parser';
 import { Cache } from './Cache';
-import type { BrsFile } from './files/BrsFile';
+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';
 /**
  * A class to keep track of all declarations within a given scope (like source scope, component scope)
  */
@@ -21,20 +24,44 @@ export declare class Scope {
      * Will be true when first constructed, or anytime one of its dependencies changes
      */
     isValidated: boolean;
-    protected cache: Cache;
+    protected cache: Cache<any, any>;
     get dependencyGraphKey(): string;
     /**
      * A dictionary of namespaces, indexed by the lower case full name of each namespace.
      * If a namespace is declared as "NameA.NameB.NameC", there will be 3 entries in this dictionary,
      * "namea", "namea.nameb", "namea.nameb.namec"
      */
-    get namespaceLookup(): Record<string, NamespaceContainer>;
+    get namespaceLookup(): Map<string, NamespaceContainer>;
     /**
      * Get the class with the specified name.
      * @param className - The class name, including the namespace of the class if possible
      * @param containingNamespace - The namespace used to resolve relative class names. (i.e. the namespace around the current statement trying to find a class)
      */
     getClass(className: string, containingNamespace?: string): ClassStatement;
+    /**
+     * Get the interface with the specified name.
+     * @param ifaceName - The interface name, including the namespace of the interface if possible
+     * @param containingNamespace - The namespace used to resolve relative interface names. (i.e. the namespace around the current statement trying to find a interface)
+     */
+    getInterface(ifaceName: string, containingNamespace?: string): InterfaceStatement;
+    /**
+     * Get either the class or interface, etc. with a given name
+     * @param name - The name, including the namespace of the interface if possible
+     * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find the interface or class)
+     */
+    getNamedTypeStatement(name: string, containingNamespace?: string): NamedTypeStatement;
+    /**
+     * A cache of a map of tokens -> TokenSymbolLookups, which are the result of getSymbolTypeFromToken()
+     * Sometimes the lookup of symbols may take a while if there are lazyTypes or multiple tokens in a chain
+     * By caching the result of this lookup, subsequent lookups of the same tokens are quicker
+     */
+    get symbolCache(): Map<Token, TokenSymbolLookup>;
+    /**
+     * Get the enum with the specified name.
+     * @param enumName - The enum name, including the namespace if possible
+     * @param containingNamespace - The namespace used to resolve relative enum names. (i.e. the namespace around the current statement trying to find an enum)
+     */
+    getEnum(enumName: string, containingNamespace?: string): EnumStatement;
     /**
      * Get a class and its containing file by the class name
      * @param className - The class name, including the namespace of the class if possible
@@ -42,16 +69,85 @@ export declare class Scope {
      */
     getClassFileLink(className: string, containingNamespace?: string): FileLink<ClassStatement>;
     /**
+   * Get an interface and its containing file by the interface name
+   * @param ifaceName - The interface name, including the namespace of the interface if possible
+   * @param containingNamespace - The namespace used to resolve relative interface names. (i.e. the namespace around the current statement trying to find a interface)
+   */
+    getInterfaceFileLink(ifaceName: string, containingNamespace?: string): FileLink<InterfaceStatement>;
+    /**
+     * Get an Enum and its containing file by the Enum name
+     * @param enumName - The Enum name, including the namespace of the enum if possible
+     * @param containingNamespace - The namespace used to resolve relative enum names. (i.e. the namespace around the current statement trying to find a enum)
+     */
+    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)
+   */
+    getNamedTypeFileLink(name: string, containingNamespace?: string): FileLink<NamedTypeStatement>;
+    /**
+     * Get a InheritableStatement and its containing file by the name of the interface or class
+     * @param name - The name of the interface or class, including the namespace of the class if possible
+     * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find a class)
+     */
+    getInheritableFileLink(name: string, containingNamespace?: string): FileLink<InheritableStatement>;
+    /**
+     * Gets the parent class of the given class
+     * @param klass - The class to get the parent of, if possible
+     */
+    getParentClass(klass: ClassStatement): ClassStatement;
+    /**
+     * Gets the parent interface of the given interface
+     * @param iface - The interface to get the parent of, if possible
+     */
+    getParentInterface(iface: InterfaceStatement): InterfaceStatement;
+    /**
+    * Gets the parent of an Interface or Class
+    * @param stmt - The class or interface to get the parent of, if possible
+    */
+    getParentStatement(stmt: InheritableStatement): InheritableStatement;
+    /**
     * Tests if a class exists with the specified name
     * @param className - the all-lower-case namespace-included class name
-    * @param namespaceName - teh current namespace name
+    * @param namespaceName - the current namespace name
     */
     hasClass(className: string, namespaceName?: string): boolean;
+    /**
+    * Tests if an interface exists with the specified name
+    * @param ifaceName - the all-lower-case namespace-included interface name
+    * @param namespaceName - the current namespace name
+    */
+    hasInterface(ifaceName: string, namespaceName?: string): boolean;
+    /**
+    * Tests if an enum exists with the specified name
+    * @param enumName - the all-lower-case namespace-included enum name
+    * @param namespaceName - the current namespace name
+    */
+    hasEnum(enumName: string, namespaceName?: string): boolean;
+    /**
+     * Tests if a class OR an interface, etc. exists with the specified name
+     * @param name - the all-lower-case namespace-included class or interface name
+     * @param namespaceName - the current namespace name
+     */
+    hasNamedType(name: string, namespaceName?: string): boolean;
     /**
      * A dictionary of all classes in this scope. This includes namespaced classes always with their full name.
      * The key is stored in lower case
      */
     getClassMap(): Map<string, FileLink<ClassStatement>>;
+    getAncestorTypeListByContext(thisType: BscType, context?: TypeContext): InheritableType[];
+    /**
+    * A dictionary of all Interfaces in this scope. This includes namespaced Interfaces always with their full name.
+    * The key is stored in lower case
+    */
+    getInterfaceMap(): Map<string, FileLink<InterfaceStatement>>;
+    getAncestorTypeList(className: string, functionExpression?: FunctionExpression): InheritableType[];
+    /**
+     * A dictionary of all enums in this scope. This includes namespaced enums always with their full name.
+     * The key is stored in lower case
+     */
+    getEnumMap(): Map<string, FileLink<EnumStatement>>;
     /**
      * The list of diagnostics found specifically for this scope. Individual file diagnostics are stored on the files themselves.
      */
@@ -83,17 +179,17 @@ export declare class Scope {
      * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
      * @param normalizePath should this function repair and standardize the path? Passing false should have a performance boost if you can guarantee your path is already sanitized
      */
-    getFile(srcPath: string, normalizePath?: boolean): BrsFile | import(".").XmlFile;
+    getFile(srcPath: string, normalizePath?: boolean): BscFile;
     /**
      * Get the list of files referenced by this scope that are actually loaded in the program.
      * Excludes files from ancestor scopes
      */
-    getOwnFiles(): (BrsFile | import(".").XmlFile)[];
+    getOwnFiles(): BscFile[];
     /**
      * Get the list of files referenced by this scope that are actually loaded in the program.
      * Includes files from this scope and all ancestor scopes
      */
-    getAllFiles(): (BrsFile | import(".").XmlFile)[];
+    getAllFiles(): BscFile[];
     /**
      * Get the list of errors for this scope. It's calculated on the fly, so
      * call this sparingly.
@@ -110,6 +206,12 @@ export declare class Scope {
      * @param name
      */
     getCallableByName(name: string): import("./interfaces").Callable;
+    /**
+     * Get the global callable with the specified name.
+     * If there are overridden callables with the same name, the closest callable to this scope is returned
+     * @param name
+     */
+    getGlobalCallableByName(name: string): import("./interfaces").Callable;
     /**
      * Iterate over Brs files not shadowed by typedefs
      */
@@ -126,7 +228,7 @@ export declare class Scope {
     /**
      * Builds a tree of namespace objects
      */
-    buildNamespaceLookup(): Record<string, NamespaceContainer>;
+    buildNamespaceLookup(): Map<string, NamespaceContainer>;
     getAllNamespaceStatements(): NamespaceStatement[];
     protected logDebug(...args: any[]): void;
     private _debugLogComponentName;
@@ -138,7 +240,9 @@ export declare class Scope {
     invalidate(): void;
     get symbolTable(): SymbolTable;
     private _symbolTable;
-    private clearSymbolTable;
+    protected _memberTable: SymbolTable;
+    get memberTable(): SymbolTable;
+    protected clearSymbolTable(): void;
     /**
     * Builds the current symbol table for the scope, by merging the tables for all the files in this scope.
     * Also links all file symbols tables to this new table
@@ -155,27 +259,19 @@ 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;
-    /**
-     * Detect calls to functions with the incorrect number of parameters
-     * @param file
-     * @param callableContainersByLowerName
-     */
-    private diagnosticDetectFunctionCallsWithWrongParamCount;
     /**
      * Detect local variables (vars declared within a function expression) that have the same name as scope calls
      * @param file
      * @param callableContainerMap
      */
     private diagnosticDetectShadowedLocalVars;
-    /**
-     * Detect calls to functions that are not defined in this scope
-     * @param file
-     * @param callablesByLowerName
-     */
-    private diagnosticDetectCallsToUnknownFunctions;
     /**
      * Create diagnostics for any duplicate function declarations
      * @param callablesByLowerName
@@ -193,7 +289,7 @@ export declare class Scope {
      * Find the file with the specified relative path
      * @param relativePath
      */
-    protected getFileByRelativePath(relativePath: string): BrsFile | import(".").XmlFile;
+    protected getFileByRelativePath(relativePath: string): BscFile;
     /**
      * Determine if this file is included in this scope (excluding parent scopes)
      * @param file
@@ -217,11 +313,11 @@ export declare class Scope {
     /**
      * @param className - The name of the class (including namespace if possible)
      * @param callsiteNamespace - the name of the namespace where the call site resides (this is NOT the known namespace of the class).
-     *                            This is used to help resolve non-namespaced class names that reside in the same namespac as the call site.
+     *                            This is used to help resolve non-namespaced class names that reside in the same namespace as the call site.
      */
     getClassHierarchy(className: string, callsiteNamespace?: string): FileLink<ClassStatement>[];
 }
-interface NamespaceContainer {
+export interface NamespaceContainer {
     file: BscFile;
     fullName: string;
     nameRange: Range;
@@ -229,7 +325,8 @@ interface NamespaceContainer {
     statements: Statement[];
     classStatements: Record<string, ClassStatement>;
     functionStatements: Record<string, FunctionStatement>;
-    namespaces: Record<string, NamespaceContainer>;
+    enumStatements: Map<string, EnumStatement>;
+    namespaces: Map<string, NamespaceContainer>;
     symbolTable: SymbolTable;
 }
 interface AugmentedNewExpression extends NewExpression {