brighterscript 0.68.5 → 0.69.1

package/dist/LanguageServer.d.ts

@@ -1,23 +1,20 @@
 import 'array-flat-polyfill';
-import type { InitializeParams, ServerCapabilities, ExecuteCommandParams, WorkspaceSymbolParams, SymbolInformation, DocumentSymbolParams } from 'vscode-languageserver/node';
-import { FileChangeType } from 'vscode-languageserver/node';
-import { ProgramBuilder } from './ProgramBuilder';
-import { Throttler } from './Throttler';
-import { BusyStatusTracker } from './BusyStatusTracker';
+import type { CompletionItem, DidChangeWatchedFilesParams, InitializeParams, TextDocumentPositionParams, ExecuteCommandParams, WorkspaceSymbolParams, DocumentSymbolParams, ReferenceParams, SignatureHelpParams, CodeActionParams, HandlerResult, InitializeError, InitializeResult, CompletionParams, ResultProgressReporter, WorkDoneProgressReporter, CompletionList, CancellationToken, DidChangeConfigurationParams } from 'vscode-languageserver/node';
+import { LogLevel } from './logging';
+import type { WorkspaceConfig } from './lsp/ProjectManager';
 export declare class LanguageServer {
-    private connection;
-    projects: Project[];
     /**
-     * The number of milliseconds that should be used for language server typing debouncing
+     * The default threading setting for the language server. Can be overridden by per-workspace settings
+     */
+    static enableThreadingDefault: boolean;
+    /**
+     * The language server protocol connection, used to send and receive all requests and responses
      */
-    private debounceTimeout;
+    private connection;
     /**
-     * These projects are created on the fly whenever a file is opened that is not included
-     * in any of the workspace-based projects.
-     * Basically these are single-file projects to at least get parsing for standalone files.
-     * Also, they should only be created when the file is opened, and destroyed when the file is closed.
+     * Manages all projects for this language server
      */
-    standaloneFileProjects: Record<string, Project>;
+    private projectManager;
     private hasConfigurationCapability;
     /**
      * Indicates whether the client supports workspace folders
@@ -28,157 +25,96 @@ export declare class LanguageServer {
      * The text document manager supports full document sync only
      */
     private documents;
-    private createConnection;
     private loggerSubscription;
-    private keyedThrottler;
-    validateThrottler: Throttler;
-    private sendDiagnosticsThrottler;
-    private boundValidateAll;
-    private validateAllThrottled;
-    busyStatusTracker: BusyStatusTracker;
-    run(): void;
-    private busyStatusIndex;
-    private sendBusyStatus;
-    /**
-     * Called when the client starts initialization
-     */
-    onInitialize(params: InitializeParams): {
-        capabilities: ServerCapabilities<any>;
-    };
-    private initialProjectsCreated;
-    /**
-     * Ask the client for the list of `files.exclude` patterns. Useful when determining if we should process a file
-     */
-    private getWorkspaceExcludeGlobs;
     /**
-     * Scan the workspace for all `bsconfig.json` files. If at least one is found, then only folders who have bsconfig.json are returned.
-     * If none are found, then the workspaceFolder itself is treated as a project
+     * Used to filter paths based on include/exclude lists (like .gitignore or vscode's `files.exclude`).
+     * This is used to prevent the language server from being overwhelmed by files we don't actually want to handle
      */
-    private getProjectPaths;
-    /**
-     * Find all folders with bsconfig.json files in them, and treat each as a project.
-     * Treat workspaces that don't have a bsconfig.json as a project.
-     * Handle situations where bsconfig.json files were added or removed (to elevate/lower workspaceFolder projects accordingly)
-     * Leave existing projects alone if they are not affected by these changes
-     */
-    private syncProjects;
+    private pathFilterer;
+    logger: import("@rokucommunity/logger/dist/Logger").Logger;
+    constructor();
+    run(): void;
     /**
-     * Get all workspace paths from the client
+     * Called when the client starts initialization
      */
-    private getWorkspacePaths;
+    onInitialize(params: InitializeParams): HandlerResult<InitializeResult, InitializeError>;
     /**
      * Called when the client has finished initializing
      */
-    private onInitialized;
+    onInitialized(): Promise<void>;
     /**
-     * Send a critical failure notification to the client, which should show a notification of some kind
+     * Set our logLevel to the most verbose log level found across all projects and workspaces
      */
-    private sendCriticalFailure;
+    private syncLogLevel;
+    private onTextDocumentDidChangeContent;
     /**
-     * Wait for all programs' first run to complete
-     */
-    private waitAllProjectFirstRuns;
-    /**
-     * Event handler for when the program wants to load file contents.
-     * anytime the program wants to load a file, check with our in-memory document cache first
-     */
-    private documentFileResolver;
-    private getConfigFilePath;
-    /**
-     * A unique project counter to help distinguish log entries in lsp mode
-     */
-    private projectCounter;
-    /**
-     * @param projectPath path to the project
-     * @param workspacePath path to the workspace in which all project should reside or are referenced by
-     * @param projectNumber an optional project number to assign to the project. Used when reloading projects that should keep the same number
+     * Called when watched files changed (add/change/delete).
+     * The CLIENT is in charge of what files to watch, so all client
+     * implementations should ensure that all valid project
+     * file types are watched (.brs,.bs,.xml,manifest, and any json/text/image files)
      */
-    private createProject;
-    private createStandaloneFileProject;
-    private getProjects;
+    onDidChangeWatchedFiles(params: DidChangeWatchedFilesParams): Promise<void>;
+    private onDocumentClose;
     /**
      * Provide a list of completion items based on the current cursor position
      */
-    private onCompletion;
-    /**
-     * Provide a full completion item from the selection
-     */
-    private onCompletionResolve;
-    private onCodeAction;
+    onCompletion(params: CompletionParams, cancellationToken: CancellationToken, workDoneProgress: WorkDoneProgressReporter, resultProgress: ResultProgressReporter<CompletionItem[]>): Promise<CompletionList>;
     /**
-     * Remove a project from the language server
+     * Get a list of workspaces, and their configurations.
+     * Get only the settings for the workspace that are relevant to the language server. We do this so we can cache this object for use in change detection in the future.
      */
-    private removeProject;
+    private getWorkspaceConfigs;
+    private workspaceConfigsCache;
+    onDidChangeConfiguration(args: DidChangeConfigurationParams): Promise<void>;
+    onHover(params: TextDocumentPositionParams): Promise<import("vscode-languageserver-types").Hover>;
+    onWorkspaceSymbol(params: WorkspaceSymbolParams): Promise<import("vscode-languageserver-types").WorkspaceSymbol[]>;
+    onDocumentSymbol(params: DocumentSymbolParams): Promise<import("vscode-languageserver-types").DocumentSymbol[]>;
+    onDefinition(params: TextDocumentPositionParams): Promise<import("vscode-languageserver-types").Location[]>;
+    onSignatureHelp(params: SignatureHelpParams): Promise<import("vscode-languageserver-types").SignatureHelp>;
+    onReferences(params: ReferenceParams): Promise<import("vscode-languageserver-types").Location[]>;
+    private onFullSemanticTokens;
+    onCodeAction(params: CodeActionParams): Promise<import("vscode-languageserver-types").CodeAction[]>;
+    onExecuteCommand(params: ExecuteCommandParams): Promise<import("./Program").FileTranspileResult>;
     /**
-     * Reload each of the specified workspaces
+     * Establish a connection to the client if not already connected
      */
-    private reloadProjects;
-    private getRootDir;
+    private establishConnection;
     /**
-     * Sometimes users will alter their bsconfig files array, and will include standalone files.
-     * If this is the case, those standalone workspaces should be removed because the file was
-     * included in an actual program now.
-     *
-     * Sometimes files that used to be included are now excluded, so those open files need to be re-processed as standalone
+     * Send a new busy status notification to the client based on the current busy status
      */
-    private synchronizeStandaloneProjects;
-    private onDidChangeConfiguration;
+    private sendBusyStatus;
+    private busyStatusIndex;
+    private pathFiltererDisposables;
     /**
-     * Called when watched files changed (add/change/delete).
-     * The CLIENT is in charge of what files to watch, so all client
-     * implementations should ensure that all valid project
-     * file types are watched (.brs,.bs,.xml,manifest, and any json/text/image files)
+     * Populate the path filterer with the client's include/exclude lists and the projects include lists
+     * @returns the instance of the path filterer
      */
-    private onDidChangeWatchedFiles;
+    private rebuildPathFilterer;
     /**
-     * This only operates on files that match the specified files globs, so it is safe to throw
-     * any file changes you receive with no unexpected side-effects
+     * Ask the client for the list of `files.exclude` patterns. Useful when determining if we should process a file
      */
-    handleFileChanges(project: Project, changes: {
-        type: FileChangeType;
-        srcPath: string;
-    }[]): Promise<void>;
+    private getWorkspaceExcludeGlobs;
     /**
-     * This only operates on files that match the specified files globs, so it is safe to throw
-     * any file changes you receive with no unexpected side-effects
+     * Ask the project manager to sync all projects found within the list of workspaces
+     * @param forceReload if true, all projects are discarded and recreated from scratch
      */
-    private handleFileChange;
-    private onHover;
-    private onDocumentClose;
-    private validateTextDocument;
-    private validateAll;
-    onWorkspaceSymbol(params: WorkspaceSymbolParams): Promise<SymbolInformation[]>;
-    onDocumentSymbol(params: DocumentSymbolParams): Promise<import("vscode-languageserver-types").DocumentSymbol[]>;
-    private onDefinition;
-    private onSignatureHelp;
-    private onReferences;
-    private onValidateSettled;
-    private onFullSemanticTokens;
-    private diagnosticCollection;
-    private sendDiagnostics;
-    onExecuteCommand(params: ExecuteCommandParams): Promise<import("./Program").FileTranspileResult>;
-    private transpileFile;
-    dispose(): void;
-}
-export interface Project {
+    private syncProjects;
     /**
-     * A unique number for this project, generated during this current language server session. Mostly used so we can identify which project is doing logging
+     * Given a workspaceFolder path, get the specified configuration from the client (if applicable).
+     * Be sure to use optional chaining to traverse the result in case that configuration doesn't exist or the client doesn't support `getConfiguration`
+     * @param workspaceFolder the folder for the workspace in the client
      */
-    projectNumber: number;
-    firstRunPromise: Promise<any>;
-    builder: ProgramBuilder;
+    private getClientConfiguration;
     /**
-     * The path to where the project resides
+     * Send a critical failure notification to the client, which should show a notification of some kind
      */
-    projectPath: string;
+    private sendCriticalFailure;
     /**
-     * The path to the workspace where this project resides. A workspace can have multiple projects (by adding a bsconfig.json to each folder).
+     * Send diagnostics to the client
      */
-    workspacePath: string;
-    isFirstRunComplete: boolean;
-    isFirstRunSuccessful: boolean;
-    configFilePath?: string;
-    isStandaloneFileProject: boolean;
+    private sendDiagnostics;
+    private diagnosticCollection;
+    protected dispose(): void;
 }
 export declare enum CustomCommands {
     TranspileFile = "TranspileFile"
@@ -186,3 +122,17 @@ export declare enum CustomCommands {
 export declare enum NotificationName {
     busyStatus = "busyStatus"
 }
+declare type Handler<T> = {
+    [K in keyof T as K extends `on${string}` ? K : never]: T[K] extends (arg: infer U) => void ? (arg: U) => void : never;
+};
+export declare type OnHandler<T> = {
+    [K in keyof Handler<T>]: Handler<T>[K] extends (arg: infer U) => void ? U : never;
+};
+export declare type WorkspaceConfigWithExtras = WorkspaceConfig & {
+    bsconfigPath: string;
+    languageServer: {
+        enableThreading: boolean;
+        logLevel: LogLevel | string | undefined;
+    };
+};
+export {};