@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/backgroundThreadBase.ts

@@ -0,0 +1,143 @@
+/*
+ * backgroundThreadBase.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * base class for background worker thread.
+ */
+
+import { MessagePort, parentPort } from 'worker_threads';
+
+import { OperationCanceledException, setCancellationFolderName } from './common/cancellationUtils';
+import { ConfigOptions } from './common/configOptions';
+import { LogLevel } from './common/console';
+import * as debug from './common/debug';
+import { FileSystem } from './common/fileSystem';
+import { FileSpec } from './common/pathUtils';
+import { createFromRealFileSystem } from './common/realFileSystem';
+import { PyrightFileSystem } from './pyrightFileSystem';
+
+export class BackgroundThreadBase {
+    protected fs: FileSystem;
+
+    protected constructor(data: InitializationData) {
+        setCancellationFolderName(data.cancellationFolderName);
+
+        // Stash the base directory into a global variable.
+        (global as any).__rootDirectory = data.rootDirectory;
+
+        this.fs = new PyrightFileSystem(createFromRealFileSystem(this.getConsole()));
+    }
+
+    protected log(level: LogLevel, msg: string) {
+        parentPort?.postMessage({ requestType: 'log', data: { level: level, message: msg } });
+    }
+
+    protected getConsole() {
+        return {
+            log: (msg: string) => {
+                this.log(LogLevel.Log, msg);
+            },
+            info: (msg: string) => {
+                this.log(LogLevel.Info, msg);
+            },
+            warn: (msg: string) => {
+                this.log(LogLevel.Warn, msg);
+            },
+            error: (msg: string) => {
+                this.log(LogLevel.Error, msg);
+            },
+            // We always generate logs in the background. For the foreground,
+            // we'll decide decide based on user setting whether.
+            level: LogLevel.Log,
+        };
+    }
+}
+
+export function createConfigOptionsFrom(jsonObject: any): ConfigOptions {
+    const configOptions = new ConfigOptions(jsonObject.projectRoot);
+    const getFileSpec = (fileSpec: any): FileSpec => {
+        return { wildcardRoot: fileSpec.wildcardRoot, regExp: new RegExp(fileSpec.regExp.source) };
+    };
+
+    configOptions.pythonPath = jsonObject.pythonPath;
+    configOptions.typeshedPath = jsonObject.typeshedPath;
+    configOptions.stubPath = jsonObject.stubPath;
+    configOptions.autoExcludeVenv = jsonObject.autoExcludeVenv;
+    configOptions.verboseOutput = jsonObject.verboseOutput;
+    configOptions.checkOnlyOpenFiles = jsonObject.checkOnlyOpenFiles;
+    configOptions.useLibraryCodeForTypes = jsonObject.useLibraryCodeForTypes;
+    configOptions.internalTestMode = jsonObject.internalTestMode;
+    configOptions.indexGenerationMode = jsonObject.indexGenerationMode;
+    configOptions.venvPath = jsonObject.venvPath;
+    configOptions.venv = jsonObject.venv;
+    configOptions.defaultPythonVersion = jsonObject.defaultPythonVersion;
+    configOptions.defaultPythonPlatform = jsonObject.defaultPythonPlatform;
+    configOptions.defaultExtraPaths = jsonObject.defaultExtraPaths;
+    configOptions.diagnosticRuleSet = jsonObject.diagnosticRuleSet;
+    configOptions.executionEnvironments = jsonObject.executionEnvironments;
+    configOptions.autoImportCompletions = jsonObject.autoImportCompletions;
+    configOptions.indexing = jsonObject.indexing;
+    configOptions.logTypeEvaluationTime = jsonObject.logTypeEvaluationTime;
+    configOptions.typeEvaluationTimeThreshold = jsonObject.typeEvaluationTimeThreshold;
+    configOptions.include = jsonObject.include.map((f: any) => getFileSpec(f));
+    configOptions.exclude = jsonObject.exclude.map((f: any) => getFileSpec(f));
+    configOptions.ignore = jsonObject.ignore.map((f: any) => getFileSpec(f));
+    configOptions.strict = jsonObject.strict.map((f: any) => getFileSpec(f));
+
+    return configOptions;
+}
+
+export function run(code: () => any, port: MessagePort) {
+    try {
+        const result = code();
+        port.postMessage({ kind: 'ok', data: result });
+    } catch (e: any) {
+        if (OperationCanceledException.is(e)) {
+            port.postMessage({ kind: 'cancelled', data: e.message });
+            return;
+        }
+
+        port.postMessage({ kind: 'failed', data: `Exception: ${e.message} in ${e.stack}` });
+    }
+}
+
+export function getBackgroundWaiter<T>(port: MessagePort): Promise<T> {
+    return new Promise((resolve, reject) => {
+        port.on('message', (m: RequestResponse) => {
+            switch (m.kind) {
+                case 'ok':
+                    resolve(m.data);
+                    break;
+
+                case 'cancelled':
+                    reject(new OperationCanceledException());
+                    break;
+
+                case 'failed':
+                    reject(m.data);
+                    break;
+
+                default:
+                    debug.fail(`unknown kind ${m.kind}`);
+            }
+        });
+    });
+}
+
+export interface InitializationData {
+    rootDirectory: string;
+    cancellationFolderName: string | undefined;
+    runner: string | undefined;
+    title?: string;
+}
+
+export interface RequestResponse {
+    kind: 'ok' | 'failed' | 'cancelled';
+    data: any;
+}
+
+export interface LogData {
+    level: LogLevel;
+    message: string;
+}

package/src/commands/commandController.ts

@@ -0,0 +1,62 @@
+/*
+ * commandController.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Implements language server commands execution functionality.
+ */
+
+import { CancellationToken, ExecuteCommandParams, ResponseError } from 'vscode-languageserver';
+
+import { LanguageServerInterface } from '../languageServerBase';
+import { Commands } from './commands';
+import { CreateTypeStubCommand } from './createTypeStub';
+import { QuickActionCommand } from './quickActionCommand';
+import { RestartServerCommand } from './restartServer';
+
+export interface ServerCommand {
+    execute(cmdParams: ExecuteCommandParams, token: CancellationToken): Promise<any>;
+}
+
+export class CommandController implements ServerCommand {
+    private _createStub: CreateTypeStubCommand;
+    private _restartServer: RestartServerCommand;
+    private _quickAction: QuickActionCommand;
+
+    constructor(ls: LanguageServerInterface) {
+        this._createStub = new CreateTypeStubCommand(ls);
+        this._restartServer = new RestartServerCommand(ls);
+        this._quickAction = new QuickActionCommand(ls);
+    }
+
+    async execute(cmdParams: ExecuteCommandParams, token: CancellationToken): Promise<any> {
+        switch (cmdParams.command) {
+            case Commands.orderImports:
+            case Commands.addMissingOptionalToParam: {
+                return this._quickAction.execute(cmdParams, token);
+            }
+
+            case Commands.createTypeStub: {
+                return this._createStub.execute(cmdParams, token);
+            }
+
+            case Commands.restartServer: {
+                return this._restartServer.execute(cmdParams);
+            }
+
+            default: {
+                return new ResponseError<string>(1, 'Unsupported command');
+            }
+        }
+    }
+
+    isLongRunningCommand(command: string): boolean {
+        switch (command) {
+            case Commands.createTypeStub:
+                return true;
+
+            default:
+                return false;
+        }
+    }
+}

package/src/commands/commandResult.ts

@@ -0,0 +1,21 @@
+/*
+ * commandResult.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * wrapper for returning custom command data
+ */
+
+import { WorkspaceEdit } from 'vscode-languageserver-types';
+
+export interface CommandResult {
+    data?: any;
+    label: string;
+    edits: WorkspaceEdit;
+}
+
+export namespace CommandResult {
+    export function is(value: any): value is CommandResult {
+        return value && value.edits && WorkspaceEdit.is(value.edits);
+    }
+}

package/src/commands/commands.ts

@@ -0,0 +1,16 @@
+/*
+ * commands.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Command identifier strings.
+ */
+
+export const enum Commands {
+    createTypeStub = 'pyright.createtypestub',
+    restartServer = 'pyright.restartserver',
+    orderImports = 'pyright.organizeimports',
+    addMissingOptionalToParam = 'pyright.addoptionalforparam',
+    unusedImport = 'pyright.unusedImport',
+}

package/src/commands/createTypeStub.ts

@@ -0,0 +1,56 @@
+/*
+ * createTypeStub.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Implements 'create stub' command functionality.
+ */
+
+import { CancellationToken, ExecuteCommandParams } from 'vscode-languageserver';
+
+import { OperationCanceledException } from '../common/cancellationUtils';
+import { LanguageServerInterface } from '../languageServerBase';
+import { AnalyzerServiceExecutor } from '../languageService/analyzerServiceExecutor';
+import { ServerCommand } from './commandController';
+
+export class CreateTypeStubCommand implements ServerCommand {
+    constructor(private _ls: LanguageServerInterface) {}
+
+    async execute(cmdParams: ExecuteCommandParams, token: CancellationToken): Promise<any> {
+        if (cmdParams.arguments && cmdParams.arguments.length >= 2) {
+            const workspaceRoot = cmdParams.arguments[0] as string;
+            const importName = cmdParams.arguments[1] as string;
+            const callingFile = cmdParams.arguments[2] as string;
+
+            const service = await AnalyzerServiceExecutor.cloneService(
+                this._ls,
+                await this._ls.getWorkspaceForFile(callingFile ?? workspaceRoot),
+                importName,
+                this._ls.createBackgroundAnalysis()
+            );
+
+            try {
+                await service.writeTypeStubInBackground(token);
+                service.dispose();
+
+                const infoMessage = `Type stub was successfully created for '${importName}'.`;
+                this._ls.window.showInformationMessage(infoMessage);
+                this._ls.reanalyze();
+            } catch (err) {
+                const isCancellation = OperationCanceledException.is(err);
+                if (isCancellation) {
+                    const errMessage = `Type stub creation for '${importName}' was canceled`;
+                    this._ls.console.error(errMessage);
+                } else {
+                    let errMessage = '';
+                    if (err instanceof Error) {
+                        errMessage = ': ' + err.message;
+                    }
+                    errMessage = `An error occurred when creating type stub for '${importName}'` + errMessage;
+                    this._ls.console.error(errMessage);
+                    this._ls.window.showErrorMessage(errMessage);
+                }
+            }
+        }
+    }
+}

package/src/commands/quickActionCommand.ts

@@ -0,0 +1,40 @@
+/*
+ * quickActionCommand.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Implements command that maps to a quick action.
+ */
+
+import { CancellationToken, ExecuteCommandParams } from 'vscode-languageserver';
+
+import { convertTextEdits } from '../common/textEditUtils';
+import { LanguageServerInterface } from '../languageServerBase';
+import { ServerCommand } from './commandController';
+import { Commands } from './commands';
+
+export class QuickActionCommand implements ServerCommand {
+    constructor(private _ls: LanguageServerInterface) {}
+
+    async execute(params: ExecuteCommandParams, token: CancellationToken): Promise<any> {
+        if (params.arguments && params.arguments.length >= 1) {
+            const docUri = params.arguments[0] as string;
+            const otherArgs = params.arguments.slice(1);
+            const filePath = this._ls.decodeTextDocumentUri(docUri);
+            const workspace = await this._ls.getWorkspaceForFile(filePath);
+
+            if (params.command === Commands.orderImports && workspace.disableOrganizeImports) {
+                return [];
+            }
+
+            const editActions = workspace.serviceInstance.performQuickAction(
+                filePath,
+                params.command,
+                otherArgs,
+                token
+            );
+
+            return convertTextEdits(docUri, editActions);
+        }
+    }
+}

package/src/commands/restartServer.ts

@@ -0,0 +1,20 @@
+/*
+ * restartServer.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Implements 'restart server' command functionality.
+ */
+
+import { ExecuteCommandParams } from 'vscode-languageserver';
+
+import { LanguageServerInterface } from '../languageServerBase';
+import { ServerCommand } from './commandController';
+
+export class RestartServerCommand implements ServerCommand {
+    constructor(private _ls: LanguageServerInterface) {}
+
+    async execute(cmdParams: ExecuteCommandParams): Promise<any> {
+        this._ls.restart();
+    }
+}

package/src/common/cancellationUtils.ts

@@ -0,0 +1,71 @@
+/*
+ * cancellationUtils.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Helper methods relating to cancellation.
+ */
+
+import { AbstractCancellationTokenSource, CancellationTokenSource } from 'vscode-jsonrpc';
+import { CancellationToken, Disposable, LSPErrorCodes, ResponseError } from 'vscode-languageserver';
+
+import { isDebugMode } from './core';
+
+export interface CancellationProvider {
+    createCancellationTokenSource(): AbstractCancellationTokenSource;
+}
+
+let cancellationFolderName: string | undefined;
+
+export function getCancellationFolderName() {
+    return cancellationFolderName;
+}
+
+export function setCancellationFolderName(folderName?: string) {
+    cancellationFolderName = folderName;
+}
+
+export class OperationCanceledException extends ResponseError<void> {
+    constructor() {
+        super(LSPErrorCodes.RequestCancelled, 'request cancelled');
+    }
+
+    static is(e: any) {
+        return e.code === LSPErrorCodes.RequestCancelled;
+    }
+}
+
+export function throwIfCancellationRequested(token: CancellationToken) {
+    // Don't use cancellation in debug mode because it interferes with
+    // debugging if requests are cancelled.
+    if (!isDebugMode() && token.isCancellationRequested) {
+        throw new OperationCanceledException();
+    }
+}
+
+export function CancelAfter(...tokens: CancellationToken[]) {
+    const source = new CancellationTokenSource();
+    const disposables: Disposable[] = [];
+
+    for (const token of tokens) {
+        disposables.push(
+            token.onCancellationRequested((_) => {
+                source.cancel();
+            })
+        );
+    }
+
+    disposables.push(
+        source.token.onCancellationRequested((_) => {
+            disposables.forEach((d) => d.dispose());
+        })
+    );
+
+    return source;
+}
+
+export class DefaultCancellationProvider implements CancellationProvider {
+    createCancellationTokenSource(): AbstractCancellationTokenSource {
+        return new CancellationTokenSource();
+    }
+}

package/src/common/chokidarFileWatcherProvider.ts

@@ -0,0 +1,74 @@
+/*
+ * chokidarFileWatcherProvider.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Implements a FileWatcherProvider using chokidar.
+ */
+
+import * as chokidar from 'chokidar';
+
+import { ConsoleInterface } from './console';
+import { FileWatcher, FileWatcherEventHandler, FileWatcherEventType, FileWatcherProvider } from './fileSystem';
+
+const _isMacintosh = process.platform === 'darwin';
+const _isLinux = process.platform === 'linux';
+
+export class ChokidarFileWatcherProvider implements FileWatcherProvider {
+    constructor(private _console?: ConsoleInterface) {}
+
+    createFileWatcher(paths: string[], listener: FileWatcherEventHandler): FileWatcher {
+        return this._createFileSystemWatcher(paths).on('all', listener);
+    }
+
+    private _createFileSystemWatcher(paths: string[]): chokidar.FSWatcher {
+        // The following options are copied from VS Code source base. It also
+        // uses chokidar for its file watching.
+        const watcherOptions: chokidar.WatchOptions = {
+            ignoreInitial: true,
+            ignorePermissionErrors: true,
+            followSymlinks: true, // this is the default of chokidar and supports file events through symlinks
+            interval: 1000, // while not used in normal cases, if any error causes chokidar to fallback to polling, increase its intervals
+            binaryInterval: 1000,
+            disableGlobbing: true, // fix https://github.com/Microsoft/vscode/issues/4586
+            awaitWriteFinish: {
+                // this will make sure we re-scan files once file changes are written to disk
+                stabilityThreshold: 1000,
+                pollInterval: 1000,
+            },
+        };
+
+        if (_isMacintosh) {
+            // Explicitly disable on MacOS because it uses up large amounts of memory
+            // and CPU for large file hierarchies, resulting in instability and crashes.
+            watcherOptions.usePolling = false;
+        }
+
+        const excludes: string[] = ['**/__pycache__/**'];
+        if (_isMacintosh || _isLinux) {
+            if (paths.some((path) => path === '' || path === '/')) {
+                excludes.push('/dev/**');
+                if (_isLinux) {
+                    excludes.push('/proc/**', '/sys/**');
+                }
+            }
+        }
+        watcherOptions.ignored = excludes;
+
+        const watcher = chokidar.watch(paths, watcherOptions);
+        watcher.on('error', (_) => {
+            this._console?.error('Error returned from file system watcher.');
+        });
+
+        // Detect if for some reason the native watcher library fails to load
+        if (_isMacintosh && !watcher.options.useFsEvents) {
+            this._console?.info('Watcher could not use native fsevents library. File system watcher disabled.');
+        }
+
+        return watcher;
+    }
+
+    onFileChange(_1: FileWatcherEventType, _2: string): void {
+        // Do nothing.
+    }
+}