@zzzen/pyright-internal 1.1.255 → 1.2.0-dev.20220703

package/src/backgroundThreadBase.ts

@@ -1,143 +0,0 @@
-/*
- * 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

@@ -1,62 +0,0 @@
-/*
- * 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

@@ -1,21 +0,0 @@
-/*
- * 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

@@ -1,16 +0,0 @@
-/*
- * 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

@@ -1,56 +0,0 @@
-/*
- * 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

@@ -1,40 +0,0 @@
-/*
- * 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

@@ -1,20 +0,0 @@
-/*
- * 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

@@ -1,71 +0,0 @@
-/*
- * 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

@@ -1,74 +0,0 @@
-/*
- * 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.
-    }
-}