@zzzen/pyright-internal 1.2.0-dev.20260705 → 1.2.0-dev.20260712

package/dist/typeServer/protocol/typeServerProtocol.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeServerProtocol = void 0;
+/*
+ * typeServerProtocol.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Defines the interfaces and types for the type server protocol. A Type Server is a module that provides type information
+ * for code, such as type definitions, member information, and diagnostics.
+ *
+ * It's Python specific at the moment, but may be made generic in the future.
+ *
+ * This protocol is used to communicate between the type server and the client (e.g., a language server or an IDE).
+ *
+ * All the types in this file should be JSON serializable, as they are sent over the wire.
+ * The protocol is designed to be extensible, allowing for future additions of new requests and notifications.
+ *
+ * Single source of truth:
+ * - Within Pyright, this `.ts` file is authoritative. The sibling `tsp.json` and
+ *   `tsp.schema.json` are GENERATED from it by `generate_json.py` (run that script
+ *   after editing this file); do not hand-edit the JSON artifacts.
+ * - Across repos, this file is a synchronized copy of the canonical shared Type Server
+ *   Protocol also consumed by Pylance. Version negotiation
+ *   (`TypeServerVersion.current`) guards against gross cross-version mismatches, but it
+ *   does NOT detect silent field-level drift within a version. Any wire-level change
+ *   must be mirrored in the other repo's copy and coordinated cross-repo so the two
+ *   cannot diverge.
+ */
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+var TypeServerProtocol;
+(function (TypeServerProtocol) {
+    TypeServerProtocol.ReturnSymbolName = '__return__'; // Special name for the return value of a function or method.
+    TypeServerProtocol.InvalidHandle = -1; // Special value for an invalid handle. This is used to indicate that a type or declaration is not valid.
+    /**
+     * Version of the type server protocol.
+     * Used for protocol negotiation between client and server to ensure compatibility.
+     *
+     * The version follows semantic versioning (semver), with the usual 0.x caveat:
+     * - Major version changes indicate breaking changes to the protocol
+     * - While the protocol is 0.x, minor version changes may indicate breaking changes
+     * - Patch version changes remain backward compatible
+     *
+     * Clients should check the server's supported version before making requests.
+     */
+    let TypeServerVersion;
+    (function (TypeServerVersion) {
+        TypeServerVersion["v0_1_0"] = "0.1.0";
+        TypeServerVersion["v0_2_0"] = "0.2.0";
+        TypeServerVersion["v0_3_0"] = "0.3.0";
+        TypeServerVersion["v0_4_0"] = "0.4.0";
+        TypeServerVersion["current"] = "0.4.1";
+    })(TypeServerVersion = TypeServerProtocol.TypeServerVersion || (TypeServerProtocol.TypeServerVersion = {}));
+    /**
+     * Built-in transport kinds supported by the multi-connection protocol.
+     *
+     * The main connection may use any transport the server supports, but extra
+     * dynamically-opened connections are negotiated separately and are currently
+     * limited to local IPC.
+     */
+    let ConnectionTransportKind;
+    (function (ConnectionTransportKind) {
+        ConnectionTransportKind["Ipc"] = "ipc";
+    })(ConnectionTransportKind = TypeServerProtocol.ConnectionTransportKind || (TypeServerProtocol.ConnectionTransportKind = {}));
+    // Flags that describe the characteristics of a type.
+    // These flags can be combined using bitwise operations.
+    let TypeFlags;
+    (function (TypeFlags) {
+        TypeFlags[TypeFlags["None"] = 0] = "None";
+        TypeFlags[TypeFlags["Instantiable"] = 1] = "Instantiable";
+        TypeFlags[TypeFlags["Instance"] = 2] = "Instance";
+        TypeFlags[TypeFlags["Callable"] = 4] = "Callable";
+        TypeFlags[TypeFlags["Literal"] = 8] = "Literal";
+        TypeFlags[TypeFlags["Interface"] = 16] = "Interface";
+        TypeFlags[TypeFlags["Generic"] = 32] = "Generic";
+        TypeFlags[TypeFlags["FromAlias"] = 64] = "FromAlias";
+        TypeFlags[TypeFlags["Unpacked"] = 128] = "Unpacked";
+        TypeFlags[TypeFlags["Optional"] = 256] = "Optional";
+        TypeFlags[TypeFlags["Unbound"] = 512] = "Unbound";
+    })(TypeFlags = TypeServerProtocol.TypeFlags || (TypeServerProtocol.TypeFlags = {}));
+    // Represents the category of a declaration in the type system.
+    // This is used to classify declarations such as variables, functions, classes, etc.
+    let DeclarationCategory;
+    (function (DeclarationCategory) {
+        DeclarationCategory[DeclarationCategory["Intrinsic"] = 0] = "Intrinsic";
+        DeclarationCategory[DeclarationCategory["Variable"] = 1] = "Variable";
+        DeclarationCategory[DeclarationCategory["Param"] = 2] = "Param";
+        DeclarationCategory[DeclarationCategory["TypeParam"] = 3] = "TypeParam";
+        DeclarationCategory[DeclarationCategory["TypeAlias"] = 4] = "TypeAlias";
+        DeclarationCategory[DeclarationCategory["Function"] = 5] = "Function";
+        DeclarationCategory[DeclarationCategory["Class"] = 6] = "Class";
+        DeclarationCategory[DeclarationCategory["Import"] = 7] = "Import";
+    })(DeclarationCategory = TypeServerProtocol.DeclarationCategory || (TypeServerProtocol.DeclarationCategory = {}));
+    /**
+     * Discriminator for the Union type.
+     * Identifies which variant of Type is being used.
+     *
+     * Used for type narrowing when processing Type objects:
+     * ```typescript
+     * if (handle.kind === TypeKind.Function) {
+     *     // TypeScript knows this is FunctionType
+     *     const returnType = handle.returnType;
+     * }
+     * ```
+     *
+     * Categories:
+     * - BuiltIn: Special types (unknown, any, never, etc.)
+     * - Declared: Base type for source declarations (rarely used directly)
+     * - Function: Function or method types from def statements
+     * - Class: Class types from class statements
+     * - Union: Multiple types combined (T1 | T2 | ...)
+     * - Module: Python module types
+     * - TypeVar: Generic type parameters (T, P, Ts)
+     * - Overloaded: Functions with @overload decorators
+     * - Synthesized: Generated stub content for type server created types
+     * - TypeReference: Reference to another type by ID
+     */
+    let TypeKind;
+    (function (TypeKind) {
+        TypeKind[TypeKind["BuiltIn"] = 0] = "BuiltIn";
+        TypeKind[TypeKind["Declared"] = 1] = "Declared";
+        TypeKind[TypeKind["Function"] = 2] = "Function";
+        TypeKind[TypeKind["Class"] = 3] = "Class";
+        TypeKind[TypeKind["Union"] = 4] = "Union";
+        TypeKind[TypeKind["Module"] = 5] = "Module";
+        TypeKind[TypeKind["TypeVar"] = 6] = "TypeVar";
+        TypeKind[TypeKind["Overloaded"] = 7] = "Overloaded";
+        TypeKind[TypeKind["Synthesized"] = 8] = "Synthesized";
+        TypeKind[TypeKind["TypeReference"] = 9] = "TypeReference";
+    })(TypeKind = TypeServerProtocol.TypeKind || (TypeServerProtocol.TypeKind = {}));
+    /**
+     * Discriminator for the Declaration union type.
+     * Distinguishes between declarations that exist in source code versus those created by the type checker.
+     *
+     * Used to determine whether a declaration:
+     * - Has an actual AST node in the parse tree (Regular)
+     * - Was created implicitly by the type system (Synthesized)
+     *
+     * Examples:
+     * - Regular: `def my_function():` - has source code node
+     * - Synthesized: `__init__` method generated by @dataclass - no source node
+     * - Regular: `class MyClass:` - has source code node
+     * - Synthesized: Built-in `len` function - no user source code
+     */
+    let DeclarationKind;
+    (function (DeclarationKind) {
+        DeclarationKind[DeclarationKind["Regular"] = 0] = "Regular";
+        DeclarationKind[DeclarationKind["Synthesized"] = 1] = "Synthesized";
+    })(DeclarationKind = TypeServerProtocol.DeclarationKind || (TypeServerProtocol.DeclarationKind = {}));
+    /**
+     * Describes the variance of a type parameter in a generic type.
+     * Variance controls how subtyping relationships work with generic types.
+     *
+     * Variance rules:
+     * - Covariant: If A is a subtype of B, then Generic[A] is a subtype of Generic[B]
+     *   - Used when the type parameter appears only in output positions (return types)
+     *   - Example: Tuple[T] is covariant in T
+     *
+     * - Contravariant: If A is a subtype of B, then Generic[B] is a subtype of Generic[A]
+     *   - Used when the type parameter appears only in input positions (parameters)
+     *   - Example: Callable[[T], None] is contravariant in T
+     *
+     * - Invariant: No subtyping relationship exists regardless of T
+     *   - Used when the type parameter appears in both input and output positions
+     *   - Example: List[T] is invariant in T
+     *
+     * Examples:
+     * ```python
+     * from typing import TypeVar, Generic
+     *
+     * T_co = TypeVar('T_co', covariant=True)      # Covariant
+     * T_contra = TypeVar('T_contra', contravariant=True)  # Contravariant
+     * T = TypeVar('T')  # Invariant by default
+     *
+     * class Container(Generic[T_co]):  # Covariant
+     *     def get(self) -> T_co: ...   # T_co in output position only
+     *
+     * class Consumer(Generic[T_contra]):  # Contravariant
+     *     def accept(self, value: T_contra) -> None: ...  # T_contra in input only
+     * ```
+     */
+    let Variance;
+    (function (Variance) {
+        Variance[Variance["Auto"] = 0] = "Auto";
+        Variance[Variance["Unknown"] = 1] = "Unknown";
+        Variance[Variance["Invariant"] = 2] = "Invariant";
+        Variance[Variance["Covariant"] = 3] = "Covariant";
+        Variance[Variance["Contravariant"] = 4] = "Contravariant";
+    })(Variance = TypeServerProtocol.Variance || (TypeServerProtocol.Variance = {}));
+    // Requests and notifications for the type server protocol.
+    // Request for the computed type of a declaration or node. Computed type is the type that is inferred based on the code flow.
+    //
+    // Example:
+    // def foo(a: int | str):
+    //     if instanceof(a, int):
+    //        b = a + 1  # Computed type of 'b' is 'int'
+    let GetComputedTypeRequest;
+    (function (GetComputedTypeRequest) {
+        GetComputedTypeRequest.method = 'typeServer/getComputedType';
+        GetComputedTypeRequest.messageDirection = vscode_languageserver_protocol_1.MessageDirection.clientToServer;
+        GetComputedTypeRequest.type = new vscode_languageserver_protocol_1.ProtocolRequestType(GetComputedTypeRequest.method);
+    })(GetComputedTypeRequest = TypeServerProtocol.GetComputedTypeRequest || (TypeServerProtocol.GetComputedTypeRequest = {}));
+    // Request for the declared type of a declaration or node. Declared type is the type that is explicitly declared in the source code.
+    //
+    // Example:
+    // def foo(a: int | str): # Declared type of parameter 'a' is 'int | str'
+    //     pass
+    let GetDeclaredTypeRequest;
+    (function (GetDeclaredTypeRequest) {
+        GetDeclaredTypeRequest.method = 'typeServer/getDeclaredType';
+        GetDeclaredTypeRequest.messageDirection = vscode_languageserver_protocol_1.MessageDirection.clientToServer;
+        GetDeclaredTypeRequest.type = new vscode_languageserver_protocol_1.ProtocolRequestType(GetDeclaredTypeRequest.method);
+    })(GetDeclaredTypeRequest = TypeServerProtocol.GetDeclaredTypeRequest || (TypeServerProtocol.GetDeclaredTypeRequest = {}));
+    // Request for the expected type of a declaration or node. Expected type is the type that the context expects.
+    //
+    // Example:
+    // def foo(a: int | str):
+    //     pass
+    // foo(4)  # Expected type of argument 'a' is 'int | str'
+    let GetExpectedTypeRequest;
+    (function (GetExpectedTypeRequest) {
+        GetExpectedTypeRequest.method = 'typeServer/getExpectedType';
+        GetExpectedTypeRequest.messageDirection = vscode_languageserver_protocol_1.MessageDirection.clientToServer;
+        GetExpectedTypeRequest.type = new vscode_languageserver_protocol_1.ProtocolRequestType(GetExpectedTypeRequest.method);
+    })(GetExpectedTypeRequest = TypeServerProtocol.GetExpectedTypeRequest || (TypeServerProtocol.GetExpectedTypeRequest = {}));
+    /**
+     * Request to get the search paths that the type server uses for Python modules.
+     */
+    let GetPythonSearchPathsRequest;
+    (function (GetPythonSearchPathsRequest) {
+        GetPythonSearchPathsRequest.method = 'typeServer/getPythonSearchPaths';
+        GetPythonSearchPathsRequest.messageDirection = vscode_languageserver_protocol_1.MessageDirection.clientToServer;
+        GetPythonSearchPathsRequest.type = new vscode_languageserver_protocol_1.ProtocolRequestType(GetPythonSearchPathsRequest.method);
+    })(GetPythonSearchPathsRequest = TypeServerProtocol.GetPythonSearchPathsRequest || (TypeServerProtocol.GetPythonSearchPathsRequest = {}));
+    /**
+     * Request from client to get the current snapshot of the type server.
+     * A snapshot is a point-in-time representation of the type server's state, including all loaded files and their types.
+     * A type server should change its snapshot whenever any type it might have returned is no longer valid. Meaning types are
+     * only usable for the snapshot they were returned with.
+     *
+     * Snapshots are not meant to survive any changes that would make the type server throw away its internal cache. They are merely an
+     * identifier to indicate to the client that the type server will accept requests for types from that snapshot.
+     */
+    let GetSnapshotRequest;
+    (function (GetSnapshotRequest) {
+        GetSnapshotRequest.method = 'typeServer/getSnapshot';
+        GetSnapshotRequest.messageDirection = vscode_languageserver_protocol_1.MessageDirection.clientToServer;
+        GetSnapshotRequest.type = new vscode_languageserver_protocol_1.ProtocolRequestType0(GetSnapshotRequest.method);
+    })(GetSnapshotRequest = TypeServerProtocol.GetSnapshotRequest || (TypeServerProtocol.GetSnapshotRequest = {}));
+    /**
+     * Request to get the version of the protocol the type server supports.
+     *
+     * Returns a string representation of the protocol version (should be semver format)
+     */
+    let GetSupportedProtocolVersionRequest;
+    (function (GetSupportedProtocolVersionRequest) {
+        GetSupportedProtocolVersionRequest.method = 'typeServer/getSupportedProtocolVersion';
+        GetSupportedProtocolVersionRequest.messageDirection = vscode_languageserver_protocol_1.MessageDirection.clientToServer;
+        GetSupportedProtocolVersionRequest.type = new vscode_languageserver_protocol_1.ProtocolRequestType0(GetSupportedProtocolVersionRequest.method);
+    })(GetSupportedProtocolVersionRequest = TypeServerProtocol.GetSupportedProtocolVersionRequest || (TypeServerProtocol.GetSupportedProtocolVersionRequest = {}));
+    /**
+     * Request to resolve an import. This is used to resolve the import name to its location in the file system.
+     */
+    let ResolveImportRequest;
+    (function (ResolveImportRequest) {
+        ResolveImportRequest.method = 'typeServer/resolveImport';
+        ResolveImportRequest.messageDirection = vscode_languageserver_protocol_1.MessageDirection.clientToServer;
+        ResolveImportRequest.type = new vscode_languageserver_protocol_1.ProtocolRequestType(ResolveImportRequest.method);
+    })(ResolveImportRequest = TypeServerProtocol.ResolveImportRequest || (TypeServerProtocol.ResolveImportRequest = {}));
+    /**
+     * Main-connection-only request used to open or close an extra TSP transport.
+     * Extra transports must remain read-only and must not be used for LSP traffic.
+     */
+    let ConnectionRequest;
+    (function (ConnectionRequest) {
+        ConnectionRequest.method = 'typeServer/connection';
+        ConnectionRequest.messageDirection = vscode_languageserver_protocol_1.MessageDirection.clientToServer;
+        ConnectionRequest.type = new vscode_languageserver_protocol_1.ProtocolRequestType(ConnectionRequest.method);
+    })(ConnectionRequest = TypeServerProtocol.ConnectionRequest || (TypeServerProtocol.ConnectionRequest = {}));
+    /**
+     * Notification sent by the server to indicate any outstanding snapshots are invalid.
+     */
+    let SnapshotChangedNotification;
+    (function (SnapshotChangedNotification) {
+        SnapshotChangedNotification.method = 'typeServer/snapshotChanged';
+        SnapshotChangedNotification.messageDirection = vscode_languageserver_protocol_1.MessageDirection.serverToClient;
+        SnapshotChangedNotification.type = new vscode_languageserver_protocol_1.ProtocolNotificationType(SnapshotChangedNotification.method);
+    })(SnapshotChangedNotification = TypeServerProtocol.SnapshotChangedNotification || (TypeServerProtocol.SnapshotChangedNotification = {}));
+})(TypeServerProtocol || (exports.TypeServerProtocol = TypeServerProtocol = {}));
+//# sourceMappingURL=typeServerProtocol.js.map

package/dist/typeServer/protocol/typeServerProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeServerProtocol.js","sourceRoot":"","sources":["../../../../../../src/typeServer/protocol/typeServerProtocol.ts"],"names":[],"mappings":"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"}

package/dist/typeServer/server.d.ts

@@ -0,0 +1,54 @@
+import { CancellationToken, Connection } from 'vscode-languageserver';
+import { CodeActionParams, DidOpenTextDocumentParams, DocumentDiagnosticParams, ExecuteCommandParams, InitializeParams, InitializeResult } from 'vscode-languageserver-protocol';
+import { CodeAction, Command } from 'vscode-languageserver-types';
+import { ImportResolver } from '../analyzer/importResolver';
+import { IPythonMode } from '../analyzer/sourceFile';
+import { IBackgroundAnalysis } from '../backgroundAnalysisBase';
+import { ConfigOptions } from '../common/configOptions';
+import { Host } from '../common/host';
+import { ServerOptions, ServerSettings } from '../common/languageServerInterface';
+import { ProgressReporter } from '../common/progressReporter';
+import { ServiceProvider } from '../common/serviceProvider';
+import { Uri } from '../common/uri/uri';
+import { LanguageServerBase } from '../languageServerBase';
+import { Workspace } from '../workspaceFactory';
+export declare class TypeServer extends LanguageServerBase {
+    private readonly _handleToUriMap;
+    private _initializedComplete;
+    private _globalTypeCache;
+    private _notebookManager;
+    private readonly _uriMapper;
+    constructor(serverOptions: ServerOptions, connection: Connection);
+    dispose(): void;
+    getWorkspaceForFile(fileUri: Uri, pythonPath?: Uri): Promise<Workspace>;
+    getContainingWorkspacesForFile(fileUri: Uri): Promise<Workspace[]>;
+    getSettings(workspace: Workspace): Promise<ServerSettings>;
+    createBackgroundAnalysis(serviceId: string, workspaceRoot: Uri): IBackgroundAnalysis | undefined;
+    protected isLongRunningCommand(command: string): boolean;
+    protected isRefactoringCommand(command: string): boolean;
+    protected executeCodeAction(params: CodeActionParams, token: CancellationToken): Promise<(Command | CodeAction)[] | undefined | null>;
+    protected createHost(): Host;
+    protected createImportResolver(serviceProvider: ServiceProvider, options: ConfigOptions, host: Host): ImportResolver;
+    protected createProgressReporter(): ProgressReporter;
+    protected executeCommand(params: ExecuteCommandParams, token: CancellationToken): Promise<any>;
+    protected setupConnection(supportedCommands: string[], supportedCodeActions: string[]): void;
+    protected initialize(params: InitializeParams, supportedCommands: string[], supportedCodeActions: string[]): Promise<InitializeResult>;
+    protected convertLspUriStringToUri(lspUri: string): Uri;
+    protected onInitialized(): void;
+    protected onWorkspaceCreated(workspace: Workspace): void;
+    protected onDidOpenTextDocument(params: DidOpenTextDocumentParams, ipythonMode?: IPythonMode): Promise<void>;
+    protected onDiagnostics(params: DocumentDiagnosticParams, token: CancellationToken): Promise<import("vscode-languageserver").RelatedFullDocumentDiagnosticReport>;
+    private _getStringValues;
+    private _getParserOutput;
+    private _getWorkspaceForUri;
+    private _getExistingIPythonMode;
+    private _getProgram;
+    private _onGetSnapshot;
+    private _onGetSupportedProtocolVersion;
+    private _onGetType;
+    private _onResolveImport;
+    private _onGetPythonSearchPaths;
+    private _onSetVirtualFileRedirect;
+    private _onRemoveVirtualFileRedirect;
+    private _onSnapshotChanged;
+}