@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/server.ts

@@ -0,0 +1,298 @@
+/*
+ * server.ts
+ *
+ * Implements pyright language server.
+ */
+
+import {
+    CancellationToken,
+    CodeAction,
+    CodeActionKind,
+    CodeActionParams,
+    Command,
+    Connection,
+    ExecuteCommandParams,
+    WorkDoneProgressServerReporter,
+} from 'vscode-languageserver';
+
+import { AnalysisResults } from './analyzer/analysis';
+import { ImportResolver } from './analyzer/importResolver';
+import { isPythonBinary } from './analyzer/pythonPathUtils';
+import { BackgroundAnalysis } from './backgroundAnalysis';
+import { BackgroundAnalysisBase } from './backgroundAnalysisBase';
+import { CommandController } from './commands/commandController';
+import { getCancellationFolderName } from './common/cancellationUtils';
+import { ConfigOptions } from './common/configOptions';
+import { ConsoleWithLogLevel, LogLevel } from './common/console';
+import { isDebugMode, isString } from './common/core';
+import { FileBasedCancellationProvider } from './common/fileBasedCancellationUtils';
+import { FileSystem } from './common/fileSystem';
+import { FullAccessHost } from './common/fullAccessHost';
+import { Host } from './common/host';
+import { resolvePaths } from './common/pathUtils';
+import { ProgressReporter } from './common/progressReporter';
+import { createFromRealFileSystem, WorkspaceFileWatcherProvider } from './common/realFileSystem';
+import { LanguageServerBase, ServerSettings, WorkspaceServiceInstance } from './languageServerBase';
+import { CodeActionProvider } from './languageService/codeActionProvider';
+import { WorkspaceMap } from './workspaceMap';
+
+const maxAnalysisTimeInForeground = { openFilesTimeInMs: 50, noOpenFilesTimeInMs: 200 };
+
+export class PyrightServer extends LanguageServerBase {
+    private _controller: CommandController;
+
+    constructor(connection: Connection) {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const version = require('../package.json').version || '';
+
+        // When executed from CLI command (pyright-langserver), __rootDirectory is
+        // already defined. When executed from VSCode extension, rootDirectory should
+        // be __dirname.
+        const rootDirectory = (global as any).__rootDirectory || __dirname;
+
+        const console = new ConsoleWithLogLevel(connection.console);
+        const workspaceMap = new WorkspaceMap();
+        const fileWatcherProvider = new WorkspaceFileWatcherProvider();
+        const fileSystem = createFromRealFileSystem(console, fileWatcherProvider);
+
+        super(
+            {
+                productName: 'Pyright',
+                rootDirectory,
+                version,
+                workspaceMap,
+                fileSystem: fileSystem,
+                fileWatcherProvider,
+                cancellationProvider: new FileBasedCancellationProvider('bg'),
+                maxAnalysisTimeInForeground,
+                supportedCodeActions: [CodeActionKind.QuickFix, CodeActionKind.SourceOrganizeImports],
+            },
+            connection,
+            console
+        );
+
+        this._controller = new CommandController(this);
+    }
+
+    async getSettings(workspace: WorkspaceServiceInstance): Promise<ServerSettings> {
+        const serverSettings: ServerSettings = {
+            watchForSourceChanges: true,
+            watchForLibraryChanges: true,
+            watchForConfigChanges: true,
+            openFilesOnly: true,
+            useLibraryCodeForTypes: false,
+            disableLanguageServices: false,
+            disableOrganizeImports: false,
+            typeCheckingMode: 'basic',
+            diagnosticSeverityOverrides: {},
+            logLevel: LogLevel.Info,
+            autoImportCompletions: true,
+        };
+
+        try {
+            const pythonSection = await this.getConfiguration(workspace.rootUri, 'python');
+            if (pythonSection) {
+                const pythonPath = pythonSection.pythonPath;
+                if (pythonPath && isString(pythonPath) && !isPythonBinary(pythonPath)) {
+                    serverSettings.pythonPath = resolvePaths(
+                        workspace.rootPath,
+                        this.expandPathVariables(workspace.rootPath, pythonPath)
+                    );
+                }
+
+                const venvPath = pythonSection.venvPath;
+
+                if (venvPath && isString(venvPath)) {
+                    serverSettings.venvPath = resolvePaths(
+                        workspace.rootPath,
+                        this.expandPathVariables(workspace.rootPath, venvPath)
+                    );
+                }
+            }
+
+            const pythonAnalysisSection = await this.getConfiguration(workspace.rootUri, 'python.analysis');
+            if (pythonAnalysisSection) {
+                const typeshedPaths = pythonAnalysisSection.typeshedPaths;
+                if (typeshedPaths && Array.isArray(typeshedPaths) && typeshedPaths.length > 0) {
+                    const typeshedPath = typeshedPaths[0];
+                    if (typeshedPath && isString(typeshedPath)) {
+                        serverSettings.typeshedPath = resolvePaths(
+                            workspace.rootPath,
+                            this.expandPathVariables(workspace.rootPath, typeshedPath)
+                        );
+                    }
+                }
+
+                const stubPath = pythonAnalysisSection.stubPath;
+                if (stubPath && isString(stubPath)) {
+                    serverSettings.stubPath = resolvePaths(
+                        workspace.rootPath,
+                        this.expandPathVariables(workspace.rootPath, stubPath)
+                    );
+                }
+
+                const diagnosticSeverityOverrides = pythonAnalysisSection.diagnosticSeverityOverrides;
+                if (diagnosticSeverityOverrides) {
+                    for (const [name, value] of Object.entries(diagnosticSeverityOverrides)) {
+                        const ruleName = this.getDiagnosticRuleName(name);
+                        const severity = this.getSeverityOverrides(value as string);
+                        if (ruleName && severity) {
+                            serverSettings.diagnosticSeverityOverrides![ruleName] = severity!;
+                        }
+                    }
+                }
+
+                if (pythonAnalysisSection.diagnosticMode !== undefined) {
+                    serverSettings.openFilesOnly = this.isOpenFilesOnly(pythonAnalysisSection.diagnosticMode);
+                } else if (pythonAnalysisSection.openFilesOnly !== undefined) {
+                    serverSettings.openFilesOnly = !!pythonAnalysisSection.openFilesOnly;
+                }
+
+                if (pythonAnalysisSection.useLibraryCodeForTypes !== undefined) {
+                    serverSettings.useLibraryCodeForTypes = !!pythonAnalysisSection.useLibraryCodeForTypes;
+                }
+
+                serverSettings.logLevel = this.convertLogLevel(pythonAnalysisSection.logLevel);
+                serverSettings.autoSearchPaths = !!pythonAnalysisSection.autoSearchPaths;
+
+                const extraPaths = pythonAnalysisSection.extraPaths;
+                if (extraPaths && Array.isArray(extraPaths) && extraPaths.length > 0) {
+                    serverSettings.extraPaths = extraPaths
+                        .filter((p) => p && isString(p))
+                        .map((p) => resolvePaths(workspace.rootPath, this.expandPathVariables(workspace.rootPath, p)));
+                }
+
+                if (pythonAnalysisSection.typeCheckingMode !== undefined) {
+                    serverSettings.typeCheckingMode = pythonAnalysisSection.typeCheckingMode;
+                }
+
+                if (pythonAnalysisSection.autoImportCompletions !== undefined) {
+                    serverSettings.autoImportCompletions = pythonAnalysisSection.autoImportCompletions;
+                }
+
+                if (
+                    serverSettings.logLevel === LogLevel.Log &&
+                    pythonAnalysisSection.logTypeEvaluationTime !== undefined
+                ) {
+                    serverSettings.logTypeEvaluationTime = pythonAnalysisSection.logTypeEvaluationTime;
+                }
+
+                if (pythonAnalysisSection.typeEvaluationTimeThreshold !== undefined) {
+                    serverSettings.typeEvaluationTimeThreshold = pythonAnalysisSection.typeEvaluationTimeThreshold;
+                }
+            } else {
+                serverSettings.autoSearchPaths = true;
+            }
+
+            const pyrightSection = await this.getConfiguration(workspace.rootUri, 'pyright');
+            if (pyrightSection) {
+                if (pyrightSection.openFilesOnly !== undefined) {
+                    serverSettings.openFilesOnly = !!pyrightSection.openFilesOnly;
+                }
+
+                if (pyrightSection.useLibraryCodeForTypes !== undefined) {
+                    serverSettings.useLibraryCodeForTypes = !!pyrightSection.useLibraryCodeForTypes;
+                }
+
+                serverSettings.disableLanguageServices = !!pyrightSection.disableLanguageServices;
+                serverSettings.disableOrganizeImports = !!pyrightSection.disableOrganizeImports;
+
+                const typeCheckingMode = pyrightSection.typeCheckingMode;
+                if (typeCheckingMode && isString(typeCheckingMode)) {
+                    serverSettings.typeCheckingMode = typeCheckingMode;
+                }
+            }
+        } catch (error) {
+            this.console.error(`Error reading settings: ${error}`);
+        }
+        return serverSettings;
+    }
+
+    createBackgroundAnalysis(): BackgroundAnalysisBase | undefined {
+        if (isDebugMode() || !getCancellationFolderName()) {
+            // Don't do background analysis if we're in debug mode or an old client
+            // is used where cancellation is not supported.
+            return undefined;
+        }
+
+        return new BackgroundAnalysis(this.console);
+    }
+
+    protected override createHost() {
+        return new FullAccessHost(this.fs);
+    }
+
+    protected override createImportResolver(fs: FileSystem, options: ConfigOptions, host: Host): ImportResolver {
+        const importResolver = new ImportResolver(fs, options, host);
+
+        // In case there was cached information in the file system related to
+        // import resolution, invalidate it now.
+        importResolver.invalidateCache();
+
+        return importResolver;
+    }
+
+    protected executeCommand(params: ExecuteCommandParams, token: CancellationToken): Promise<any> {
+        return this._controller.execute(params, token);
+    }
+
+    protected isLongRunningCommand(command: string): boolean {
+        return this._controller.isLongRunningCommand(command);
+    }
+
+    protected async executeCodeAction(
+        params: CodeActionParams,
+        token: CancellationToken
+    ): Promise<(Command | CodeAction)[] | undefined | null> {
+        this.recordUserInteractionTime();
+
+        const filePath = this._uriParser.decodeTextDocumentUri(params.textDocument.uri);
+        const workspace = await this.getWorkspaceForFile(filePath);
+        return CodeActionProvider.getCodeActionsForPosition(workspace, filePath, params.range, token);
+    }
+
+    protected createProgressReporter(): ProgressReporter {
+        // The old progress notifications are kept for backwards compatibility with
+        // clients that do not support work done progress.
+
+        let workDoneProgress: Promise<WorkDoneProgressServerReporter> | undefined;
+        return {
+            isEnabled: (data: AnalysisResults) => true,
+            begin: () => {
+                if (this.client.hasWindowProgressCapability) {
+                    workDoneProgress = this._connection.window.createWorkDoneProgress();
+                    workDoneProgress
+                        .then((progress) => {
+                            progress.begin('');
+                        })
+                        .ignoreErrors();
+                } else {
+                    this._connection.sendNotification('pyright/beginProgress');
+                }
+            },
+            report: (message: string) => {
+                if (workDoneProgress) {
+                    workDoneProgress
+                        .then((progress) => {
+                            progress.report(message);
+                        })
+                        .ignoreErrors();
+                } else {
+                    this._connection.sendNotification('pyright/reportProgress', message);
+                }
+            },
+            end: () => {
+                if (workDoneProgress) {
+                    workDoneProgress
+                        .then((progress) => {
+                            progress.done();
+                        })
+                        .ignoreErrors();
+                    workDoneProgress = undefined;
+                } else {
+                    this._connection.sendNotification('pyright/endProgress');
+                }
+            },
+        };
+    }
+}

package/src/tests/chainedSourceFiles.test.ts

@@ -0,0 +1,183 @@
+/*
+ * chainedSourceFiles.test.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Unit tests for tokenizer ipython mode
+ */
+
+import assert from 'assert';
+import { CancellationToken } from 'vscode-jsonrpc';
+import { MarkupKind } from 'vscode-languageserver-types';
+
+import { Program } from '../analyzer/program';
+import { AnalyzerService } from '../analyzer/service';
+import { ConfigOptions } from '../common/configOptions';
+import { NullConsole } from '../common/console';
+import { normalizeSlashes } from '../common/pathUtils';
+import { convertOffsetsToRange, convertOffsetToPosition } from '../common/positionUtils';
+import { parseTestData } from './harness/fourslash/fourSlashParser';
+import { TestAccessHost } from './harness/testAccessHost';
+import * as host from './harness/testHost';
+import { createFromFileSystem, distlibFolder, libFolder } from './harness/vfs/factory';
+import * as vfs from './harness/vfs/filesystem';
+
+test('check chained files', async () => {
+    const code = `
+// @filename: test1.py
+//// def foo1(): pass
+
+// @filename: test2.py
+//// def foo2(): pass
+
+// @filename: test3.py
+//// def foo3(): pass
+
+// @filename: test4.py
+//// [|foo/*marker*/|]
+    `;
+
+    const basePath = normalizeSlashes('/');
+    const { data, service } = createServiceWithChainedSourceFiles(basePath, code);
+
+    const marker = data.markerPositions.get('marker')!;
+
+    const parseResult = service.getParseResult(marker.fileName)!;
+    const result = await service.getCompletionsForPosition(
+        marker.fileName,
+        convertOffsetToPosition(marker.position, parseResult.tokenizerOutput.lines),
+        basePath,
+        {
+            format: MarkupKind.Markdown,
+            lazyEdit: false,
+            snippet: false,
+            autoImport: false,
+        },
+        undefined,
+        CancellationToken.None
+    );
+
+    assert(result?.completionList?.items.some((i) => i.label === 'foo1'));
+    assert(result?.completionList?.items.some((i) => i.label === 'foo2'));
+    assert(result?.completionList?.items.some((i) => i.label === 'foo3'));
+});
+
+test('modify chained files', async () => {
+    const code = `
+// @filename: test1.py
+//// def foo1(): pass
+
+// @filename: test2.py
+//// [|/*delete*/|]
+//// def foo2(): pass
+
+// @filename: test3.py
+//// def foo3(): pass
+
+// @filename: test4.py
+//// [|foo/*marker*/|]
+    `;
+
+    const basePath = normalizeSlashes('/');
+    const { data, service } = createServiceWithChainedSourceFiles(basePath, code);
+
+    // Make sure files are all realized.
+    const marker = data.markerPositions.get('marker')!;
+    const parseResult = service.getParseResult(marker.fileName)!;
+
+    // Close file in the middle of the chain
+    service.setFileClosed(data.markerPositions.get('delete')!.fileName);
+
+    const result = await service.getCompletionsForPosition(
+        marker.fileName,
+        convertOffsetToPosition(marker.position, parseResult.tokenizerOutput.lines),
+        basePath,
+        {
+            format: MarkupKind.Markdown,
+            lazyEdit: false,
+            snippet: false,
+            autoImport: false,
+        },
+        undefined,
+        CancellationToken.None
+    );
+
+    assert(result);
+
+    assert(!result.completionList?.items.some((i) => i.label === 'foo1'));
+    assert(!result.completionList?.items.some((i) => i.label === 'foo2'));
+    assert(result.completionList?.items.some((i) => i.label === 'foo3'));
+});
+
+test('modify chained files', async () => {
+    const code = `
+// @filename: test1.py
+//// [|/*changed*/|]
+//// def foo1(): pass
+
+// @filename: test2.py
+//// def foo2(): pass
+
+// @filename: test3.py
+//// def foo3(): pass
+
+// @filename: test4.py
+//// [|/*marker*/foo1()|]
+    `;
+
+    const basePath = normalizeSlashes('/');
+    const { data, service } = createServiceWithChainedSourceFiles(basePath, code);
+
+    const marker = data.markerPositions.get('marker')!;
+    const range = data.ranges.find((r) => r.marker === marker)!;
+
+    const parseResults = service.getParseResult(marker.fileName)!;
+    analyze(service.test_program);
+
+    // Initially, there should be no error.
+    const initialDiags = await service.getDiagnosticsForRange(
+        marker.fileName,
+        convertOffsetsToRange(range.pos, range.end, parseResults.tokenizerOutput.lines),
+        CancellationToken.None
+    );
+
+    assert.strictEqual(initialDiags.length, 0);
+
+    // Change test1 content
+    service.updateOpenFileContents(data.markerPositions.get('changed')!.fileName, 2, [{ text: 'def foo5(): pass' }]);
+    analyze(service.test_program);
+
+    const finalDiags = await service.getDiagnosticsForRange(
+        marker.fileName,
+        convertOffsetsToRange(range.pos, range.end, parseResults.tokenizerOutput.lines),
+        CancellationToken.None
+    );
+
+    assert.strictEqual(finalDiags.length, 1);
+});
+
+function createServiceWithChainedSourceFiles(basePath: string, code: string) {
+    const service = new AnalyzerService(
+        'test service',
+        createFromFileSystem(host.HOST, /*ignoreCase*/ false, { cwd: basePath }),
+        new NullConsole(),
+        () => new TestAccessHost(vfs.MODULE_PATH, [libFolder, distlibFolder]),
+        AnalyzerService.createImportResolver,
+        new ConfigOptions(basePath)
+    );
+
+    const data = parseTestData(basePath, code, '');
+
+    let chainedFilePath: string | undefined;
+    for (const file of data.files) {
+        service.setFileOpened(file.fileName, 1, file.content, false, chainedFilePath);
+        chainedFilePath = file.fileName;
+    }
+    return { data, service };
+}
+
+function analyze(program: Program) {
+    while (program.analyze()) {
+        // Process all queued items
+    }
+}