brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/files/BrsFile.d.ts

@@ -1,73 +1,130 @@
 import type { CodeWithSourceMap } from 'source-map';
-import type { CompletionItem, Hover, Position } from 'vscode-languageserver';
-import { Location, SignatureInformation, DocumentSymbol, SymbolInformation } from 'vscode-languageserver';
-import type { Scope } from '../Scope';
-import type { Callable, CommentFlag, FunctionCall, BsDiagnostic, FileReference } from '../interfaces';
-import type { Token } from '../lexer';
-import { TokenKind } from '../lexer';
-import { Parser, ParseMode } from '../parser';
-import type { FunctionExpression, Expression } from '../parser/Expression';
-import type { ClassStatement, Statement } from '../parser/Statement';
-import type { FileLink, Program, SignatureInfoObj } from '../Program';
-import type { DependencyGraph } from '../DependencyGraph';
+import type { CompletionItem, Position, Location } from 'vscode-languageserver';
+import type { NamespaceFileContribution } from '../Scope';
+import { SymbolTable } from '../SymbolTable';
+import { FunctionScope } from '../FunctionScope';
+import type { Callable, CommentFlag, FileReference, FileLink, SerializedCodeFile } from '../interfaces';
+import type { NamespaceContainer } from '../Scope';
+import type { Token } from '../lexer/Token';
+import { TokenKind } from '../lexer/TokenKind';
+import { Parser, ParseMode } from '../parser/Parser';
+import type { FunctionExpression } from '../parser/Expression';
+import type { ClassStatement, NamespaceStatement, MethodStatement } from '../parser/Statement';
+import type { Program } from '../Program';
+import type { DependencyChangedEvent, DependencyGraph } from '../DependencyGraph';
+import type { AstNode, Expression } from '../parser/AstNode';
+import type { UnresolvedSymbol, AssignedSymbol } from '../AstValidationSegmenter';
+import { AstValidationSegmenter } from '../AstValidationSegmenter';
+import type { BscSymbol } from '../SymbolTable';
+import { SymbolTypeFlag } from '../SymbolTypeFlag';
+import { Editor } from '../astUtils/Editor';
+import type { BscFile } from './BscFile';
+export interface ProvidedSymbol {
+    symbol: BscSymbol;
+    duplicates: BscSymbol[];
+    requiredSymbolNames?: Set<string>;
+}
+export declare type ProvidedSymbolMap = Map<SymbolTypeFlag, Map<string, ProvidedSymbol>>;
+export declare type ChangedSymbolMap = Map<SymbolTypeFlag, Set<string>>;
+export interface ProvidedSymbolInfo {
+    symbolMap: ProvidedSymbolMap;
+    changes: ChangedSymbolMap;
+}
 /**
  * Holds all details about this file within the scope of the whole program
  */
-export declare class BrsFile {
-    /**
-     * The absolute path to the source file on disk (e.g. '/usr/you/projects/RokuApp/source/main.brs' or 'c:/projects/RokuApp/source/main.brs').
-     */
+export declare class BrsFile implements BscFile {
+    constructor(options: {
+        /**
+         * The path to the file in its source location (where the source code lives in the file system)
+         */
+        srcPath: string;
+        /**
+         * The path to the file where it should exist in the program. This is similar to pkgPath, but retains its original file extensions from srcPath
+         */
+        destPath: string;
+        /**
+         * The final path in the zip. This has the extensions changed. Typically this is the same as destPath, but with file extensions changed for transpiled files.
+         */
+        pkgPath?: string;
+        program: Program;
+    });
+    type: string;
     srcPath: string;
-    /**
-     * The full pkg path (i.e. `pkg:/path/to/file.brs`)
-     */
+    destPath: string;
     pkgPath: string;
     program: Program;
-    constructor(
+    private _cachedLookups;
     /**
-     * The absolute path to the source file on disk (e.g. '/usr/you/projects/RokuApp/source/main.brs' or 'c:/projects/RokuApp/source/main.brs').
+     * An editor assigned during the build flow that manages edits that will be undone once the build process is complete.
      */
-    srcPath: string, 
+    editor?: Editor;
     /**
-     * The full pkg path (i.e. `pkg:/path/to/file.brs`)
+     * Will this file result in only comment or whitespace output? If so, it can be excluded from the output if that bsconfig setting is enabled.
      */
-    pkgPath: string, program: Program);
+    get canBePruned(): boolean;
     /**
      * The parseMode used for the parser for this file
      */
     parseMode: ParseMode;
     /**
-     * The key used to identify this file in the dependency graph
+     * The key used to identify this file in the dependency graph. This is set by the BrighterScript program and should not be set by plugins
      */
     dependencyGraphKey: string;
-    /**
-     * The all-lowercase extension for this file (including the leading dot)
-     */
-    extension: string;
     /**
      * Indicates whether this file needs to be validated.
+     * Files are only ever validated a single time
      */
     isValidated: boolean;
-    private diagnostics;
-    getDiagnostics(): BsDiagnostic[];
-    addDiagnostics(diagnostics: BsDiagnostic[]): void;
+    /**
+     * The all-lowercase extension for this file (including the leading dot)
+     */
+    extension: string;
     commentFlags: CommentFlag[];
-    callables: Callable[];
-    functionCalls: FunctionCall[];
+    private _functionScopes;
+    get functionScopes(): FunctionScope[];
+    private get cache();
+    /**
+     * Return this file's per-namespace contributions. Cached on the file's parser-level
+     * cache, so the result is invalidated automatically when the file re-parses.
+     *
+     * Each entry covers a single dotted name part (so a `namespace A.B.C` declaration
+     * produces entries for `A`, `A.B`, and `A.B.C`). Intermediates carry only structural
+     * fields; leaves populate the relevant statement collections plus a single-file
+     * symbolTable. The symbolTable has no parent provider (see Phase 4 design notes).
+     *
+     * The returned Map is shared across every Scope that pulls in this file, which is
+     * the core sharing primitive Phase 4 relies on.
+     * @internal
+     */
+    protected getNamespaceContributions(): Map<string, NamespaceFileContribution>;
     /**
      * files referenced by import statements
      */
-    ownScriptImports: FileReference[];
+    get ownScriptImports(): FileReference[];
     /**
      * Does this file need to be transpiled?
+     * @deprecated use the `.editor` property to push changes to the file, which will force transpilation
      */
-    needsTranspiled: boolean;
+    get needsTranspiled(): boolean;
+    set needsTranspiled(value: boolean);
+    _needsTranspiled: boolean;
     /**
      * The AST for this file
      */
-    get ast(): import("../parser").Body;
-    private documentSymbols;
-    private workspaceSymbols;
+    get ast(): import("../parser/Statement").Body;
+    /**
+     * Get the token at the specified position
+     */
+    getTokenAt(position: Position): Token;
+    /**
+     * Get the token at the specified position, or the next token
+     */
+    getCurrentOrNextTokenAt(position: Position): Token;
+    /**
+     * Walk the AST and find the expression that this token is most specifically contained within
+     */
+    getClosestExpression(position: Position): AstNode;
     get parser(): Parser;
     private _parser;
     fileContents: string;
@@ -76,10 +133,10 @@ export declare class BrsFile {
      */
     isTypedef: boolean;
     /**
-     * The srcPath to the potential typedef file for this file.
+     * The key to find the typedef file in the program's files map.
      * A falsey value means this file is ineligable for a typedef
      */
-    typedefSrcPath?: string;
+    typedefKey?: string;
     /**
      * If the file was given type definitions during parse
      */
@@ -88,26 +145,26 @@ export declare class BrsFile {
      * A reference to the typedef file (if one exists)
      */
     typedefFile?: BrsFile;
-    /**
-     * An unsubscribe function for the dependencyGraph subscription
-     */
-    private unsubscribeFromDependencyGraph;
     /**
      * Find and set the typedef variables (if a matching typedef file exists)
      */
     private resolveTypedef;
+    onDependenciesChanged(event: DependencyChangedEvent): void;
     /**
      * Attach the file to the dependency graph so it can monitor changes.
      * Also notify the dependency graph of our current dependencies so other dependents can be notified.
+     * @deprecated this does nothing. This functionality is now handled by the file api and will be deleted in v1
      */
     attachDependencyGraph(dependencyGraph: DependencyGraph): void;
+    /**
+     * The list of files that this file depends on
+     */
+    get dependencies(): string[];
     /**
      * Calculate the AST for this file
-     * @param fileContents
+     * @param fileContents the raw source code to parse
      */
     parse(fileContents: string): void;
-    validate(): void;
-    findAndValidateImportAndImportStatements(): void;
     /**
      * Find a class. This scans all scopes for this file, and returns the first matching class that is found.
      * Returns undefined if not found.
@@ -121,78 +178,95 @@ export declare class BrsFile {
     get propertyNameCompletions(): CompletionItem[];
     /**
      * Find all comment flags in the source code. These enable or disable diagnostic messages.
-     * @param lines - the lines of the program
+     * @param tokens - an array of tokens of which to find `TokenKind.Comment` from
      */
     getCommentFlags(tokens: Token[]): void;
-    private findCallables;
-    private findFunctionCalls;
+    scopesByFunc: Map<FunctionExpression, FunctionScope>;
     /**
-     * Find the function expression at the given position.
+     * Create a scope for every function in this file
      */
-    getFunctionExpressionAtPosition(position: Position, functionExpressions?: FunctionExpression[]): FunctionExpression;
+    private createFunctionScopes;
+    staticCallables: Callable[];
+    get callables(): Callable[];
     /**
-     * Get completions available at the given cursor. This aggregates all values from this file and the current scope.
+     * Find the function scope at the given position.
+     * @param position the position used to find the deepest scope that contains it
      */
-    getCompletions(position: Position, scope?: Scope): CompletionItem[];
-    private getLabelCompletion;
-    private getClassMemberCompletions;
-    getClassFromMReference(position: Position, currentToken: Token, functionExpression: FunctionExpression): FileLink<ClassStatement> | undefined;
-    private getGlobalClassStatementCompletions;
-    private getNamespaceCompletions;
-    private getNamespaceDefinitions;
+    getFunctionScopeAtPosition(position: Position): FunctionScope;
+    _getFunctionScopeAtPosition(position: Position, functionScopes?: FunctionScope[]): FunctionScope;
+    /**
+     * Find the NamespaceStatement enclosing the given position
+     */
+    getNamespaceStatementForPosition(position: Position): NamespaceStatement;
     /**
      * Given a current token, walk
      */
     getPartialVariableName(currentToken: Token, excludeTokens?: TokenKind[]): string;
-    /**
-     * Find the first scope that has a namespace with this name.
+    isPositionNextToTokenKind(position: Position, tokenKind: TokenKind): boolean;
+    isTokenNextToTokenKind(closestToken: Token, tokenKind: TokenKind): boolean;
+    getTokenBefore(currentToken: Token, tokenKind?: TokenKind): Token;
+    tokenFollows(currentToken: Token, tokenKind: TokenKind): boolean;
+    getTokensUntil(currentToken: Token, tokenKind: TokenKind, direction?: -1 | 1): any[];
+    getNextTokenByPredicate(currentToken: Token, test: (Token: any) => boolean, direction?: -1 | 1): Token;
+    getPreviousToken(token: Token): Token;
+    /**
+     * Finds the first scope for this file, then returns true if there's a namespace with this name.
      * Returns false if no namespace was found with that name
      */
     calleeStartsWithNamespace(callee: Expression): boolean;
     /**
-     * Determine if the callee (i.e. function name) is a known function declared on the given namespace.
+     * Get the token closest to the position. if no token is found, the previous token is returned
      */
-    calleeIsKnownNamespaceFunction(callee: Expression, namespaceName: string): boolean;
+    getClosestToken(position: Position): Token;
     /**
      * Builds a list of document symbols for this file. Used by LanguageServer's onDocumentSymbol functionality
+     * @deprecated use `DocumentSymbolProvider.process()` instead
      */
-    getDocumentSymbols(): DocumentSymbol[];
+    getDocumentSymbols(): import("vscode-languageserver-types").DocumentSymbol[];
     /**
      * Builds a list of workspace symbols for this file. Used by LanguageServer's onWorkspaceSymbol functionality
      */
-    getWorkspaceSymbols(): SymbolInformation[];
-    /**
-     * Builds a single DocumentSymbol object for use by LanguageServer's onDocumentSymbol functionality
-     */
-    private getDocumentSymbol;
-    /**
-     * Builds a single SymbolInformation object for use by LanguageServer's onWorkspaceSymbol functionality
-     */
-    private generateWorkspaceSymbols;
+    getWorkspaceSymbols(): import("vscode-languageserver-types").WorkspaceSymbol[];
     /**
      * Given a position in a file, if the position is sitting on some type of identifier,
      * go to the definition of that identifier (where this thing was first defined)
+     * @deprecated use `DefinitionProvider.process()` instead
      */
     getDefinition(position: Position): Location[];
     getClassMemberDefinitions(textToSearchFor: string, file: BrsFile): Location[];
-    getHover(position: Position): Hover;
-    getSignatureHelpForNamespaceMethods(callableName: string, dottedGetText: string, scope: Scope): {
-        key: string;
-        signature: SignatureInformation;
-    }[];
-    getSignatureHelpForStatement(statement: Statement): SignatureInfoObj;
-    private getClassMethod;
-    getClassSignatureHelp(classStatement: ClassStatement): SignatureInfoObj | undefined;
+    getClassMethod(classStatement: ClassStatement, name: string, walkParents?: boolean): MethodStatement | undefined;
+    /**
+     * Given a position in a file, if the position is sitting on some type of identifier,
+     * look up all references of that identifier (every place that identifier is used across the whole app)
+     * @deprecated use `ReferencesProvider.process()` instead
+     */
     getReferences(position: Position): Location[];
+    /**
+     * Generate the code, map, and typedef for this file
+     */
+    serialize(): SerializedCodeFile;
     /**
      * Convert the brightscript/brighterscript source code into valid brightscript
      */
     transpile(): CodeWithSourceMap;
+    validationSegmenter: AstValidationSegmenter;
+    getNamespaceSymbolTable(allowCache?: boolean): SymbolTable;
+    private constructNamespaceSymbolTable;
+    processSymbolInformation(): void;
+    unlinkNamespaceSymbolTables(): void;
+    private linkSymbolTableDisposables;
+    populateNameSpaceSymbolTable(namespaceSymbolTable: SymbolTable): void;
+    get requiredSymbols(): UnresolvedSymbol[];
+    get providedSymbols(): {
+        symbolMap: Map<SymbolTypeFlag, Map<string, ProvidedSymbol>>;
+        changes: Map<SymbolTypeFlag, Set<string>>;
+        referenceSymbolMap: Map<SymbolTypeFlag, Map<string, ProvidedSymbol>>;
+    };
+    get assignedSymbols(): AssignedSymbol[];
+    private getProvidedSymbols;
+    markSegmentAsValidated(node: AstNode): void;
+    getNamespaceLookupObject(): Map<string, NamespaceContainer>;
+    private buildNamespaceLookup;
     getTypedef(): string;
     dispose(): void;
 }
-/**
- * List of completions for all valid keywords/reserved words.
- * Build this list once because it won't change for the lifetime of this process
- */
-export declare const KeywordCompletions: CompletionItem[];