@zzzen/pyright-internal 1.1.254 → 1.1.255

package/package.json

@@ -2,10 +2,11 @@
     "name": "@zzzen/pyright-internal",
     "displayName": "pyright",
     "description": "Type checker for the Python language",
-    "version": "1.1.254",
+    "version": "1.1.255",
     "license": "MIT",
     "files": [
-        "dist"
+        "dist",
+        "src"
     ],
     "scripts": {
         "build": "tsc",

package/src/analyzer/aliasDeclarationUtils.ts

@@ -0,0 +1,169 @@
+/*
+ * aliasDeclarationUtils.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Helper functions around alias declarations.
+ */
+
+import { ImportLookup, ImportLookupResult } from './analyzerFileInfo';
+import { Declaration, DeclarationType } from './declaration';
+import { Symbol } from './symbol';
+
+export interface ResolvedAliasInfo {
+    declaration: Declaration | undefined;
+    isPrivate: boolean;
+    privatePyTypedImported?: string;
+    privatePyTypedImporter?: string;
+}
+
+// If the specified declaration is an alias declaration that points to a symbol,
+// it resolves the alias and looks up the symbol, then returns the a declaration
+// (typically the last) associated with that symbol. It does this recursively if
+// necessary. If a symbol lookup fails, undefined is returned. If resolveLocalNames
+// is true, the method resolves aliases through local renames ("as" clauses found
+// in import statements).
+export function resolveAliasDeclaration(
+    importLookup: ImportLookup,
+    declaration: Declaration,
+    resolveLocalNames: boolean,
+    allowExternallyHiddenAccess: boolean
+): ResolvedAliasInfo | undefined {
+    let curDeclaration: Declaration | undefined = declaration;
+    const alreadyVisited: Declaration[] = [];
+    let isPrivate = false;
+    let isPrivatePyTypedImport = false;
+    let privatePyTypedImported: string | undefined;
+    let privatePyTypedImporter: string | undefined;
+
+    while (true) {
+        if (curDeclaration.type !== DeclarationType.Alias || !curDeclaration.symbolName) {
+            return {
+                declaration: curDeclaration,
+                isPrivate,
+                privatePyTypedImported,
+                privatePyTypedImporter,
+            };
+        }
+
+        // If we are not supposed to follow local alias names and this
+        // is a local name, don't continue to follow the alias.
+        if (!resolveLocalNames && curDeclaration.usesLocalName) {
+            return {
+                declaration: curDeclaration,
+                isPrivate,
+                privatePyTypedImported,
+                privatePyTypedImporter,
+            };
+        }
+
+        let lookupResult: ImportLookupResult | undefined;
+        if (curDeclaration.path && curDeclaration.loadSymbolsFromPath) {
+            lookupResult = importLookup(curDeclaration.path);
+        }
+
+        const symbol: Symbol | undefined = lookupResult
+            ? lookupResult.symbolTable.get(curDeclaration.symbolName)
+            : undefined;
+        if (!symbol) {
+            if (curDeclaration.submoduleFallback) {
+                return resolveAliasDeclaration(
+                    importLookup,
+                    curDeclaration.submoduleFallback,
+                    resolveLocalNames,
+                    allowExternallyHiddenAccess
+                );
+            }
+
+            // If the symbol comes from a native library, we won't
+            // be able to resolve its type directly.
+            if (curDeclaration.isNativeLib) {
+                return {
+                    declaration: undefined,
+                    isPrivate,
+                };
+            }
+
+            return undefined;
+        }
+
+        if (symbol.isPrivateMember()) {
+            isPrivate = true;
+        }
+
+        if (symbol.isExternallyHidden() && !allowExternallyHiddenAccess) {
+            return undefined;
+        }
+
+        // Prefer declarations with specified types. If we don't have any of those,
+        // fall back on declarations with inferred types.
+        let declarations = symbol.getTypedDeclarations();
+
+        // Try not to use declarations within an except suite even if it's a typed
+        // declaration. These are typically used for fallback exception handling.
+        declarations = declarations.filter((decl) => !decl.isInExceptSuite);
+
+        if (declarations.length === 0) {
+            declarations = symbol.getDeclarations();
+            declarations = declarations.filter((decl) => !decl.isInExceptSuite);
+        }
+
+        if (declarations.length === 0) {
+            // Use declarations within except clauses if there are no alternatives.
+            declarations = symbol.getDeclarations();
+        }
+
+        if (declarations.length === 0) {
+            return undefined;
+        }
+
+        // Prefer the last unvisited declaration in the list. This ensures that
+        // we use all of the overloads if it's an overloaded function.
+        const unvisitedDecls = declarations.filter((decl) => !alreadyVisited.includes(decl));
+        if (unvisitedDecls.length > 0) {
+            curDeclaration = unvisitedDecls[unvisitedDecls.length - 1];
+        } else {
+            curDeclaration = declarations[declarations.length - 1];
+        }
+
+        if (isPrivatePyTypedImport) {
+            privatePyTypedImported = privatePyTypedImported ?? curDeclaration?.moduleName;
+        }
+
+        if (symbol.isPrivatePyTypedImport()) {
+            isPrivatePyTypedImport = true;
+        }
+
+        if (isPrivatePyTypedImport) {
+            privatePyTypedImporter = privatePyTypedImporter ?? curDeclaration?.moduleName;
+        }
+
+        // Make sure we don't follow a circular list indefinitely.
+        if (alreadyVisited.find((decl) => decl === curDeclaration)) {
+            // If the path path of the alias points back to the original path, use the submodule
+            // fallback instead. This happens in the case where a module's __init__.py file
+            // imports a submodule using itself as the import target. For example, if
+            // the module is foo, and the foo.__init__.py file contains the statement
+            // "from foo import bar", we want to import the foo/bar.py submodule.
+            if (
+                curDeclaration.path === declaration.path &&
+                curDeclaration.type === DeclarationType.Alias &&
+                curDeclaration.submoduleFallback
+            ) {
+                return resolveAliasDeclaration(
+                    importLookup,
+                    curDeclaration.submoduleFallback,
+                    resolveLocalNames,
+                    allowExternallyHiddenAccess
+                );
+            }
+            return {
+                declaration,
+                isPrivate,
+                privatePyTypedImported,
+                privatePyTypedImporter,
+            };
+        }
+        alreadyVisited.push(curDeclaration);
+    }
+}

package/src/analyzer/analysis.ts

@@ -0,0 +1,92 @@
+/*
+ * analysis.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Various analysis helper types and functions
+ */
+
+import { CancellationToken } from 'vscode-languageserver';
+
+import { OperationCanceledException, throwIfCancellationRequested } from '../common/cancellationUtils';
+import { ConfigOptions } from '../common/configOptions';
+import { ConsoleInterface } from '../common/console';
+import * as debug from '../common/debug';
+import { FileDiagnostics } from '../common/diagnosticSink';
+import { Duration } from '../common/timing';
+import { MaxAnalysisTime, Program } from './program';
+
+export const nullCallback: AnalysisCompleteCallback = (_) => {
+    /* empty */
+};
+
+export interface AnalysisResults {
+    diagnostics: FileDiagnostics[];
+    filesInProgram: number;
+    checkingOnlyOpenFiles: boolean;
+    filesRequiringAnalysis: number;
+    fatalErrorOccurred: boolean;
+    configParseErrorOccurred: boolean;
+    elapsedTime: number;
+    error?: Error | undefined;
+}
+
+export type AnalysisCompleteCallback = (results: AnalysisResults) => void;
+
+export function analyzeProgram(
+    program: Program,
+    maxTime: MaxAnalysisTime | undefined,
+    configOptions: ConfigOptions,
+    callback: AnalysisCompleteCallback | undefined,
+    console: ConsoleInterface,
+    token: CancellationToken
+): boolean {
+    let moreToAnalyze = false;
+
+    callback = callback ?? nullCallback;
+
+    try {
+        throwIfCancellationRequested(token);
+
+        const duration = new Duration();
+        moreToAnalyze = program.analyze(maxTime, token);
+
+        const filesLeftToAnalyze = program.getFilesToAnalyzeCount();
+        const diagnostics = program.getDiagnostics(configOptions);
+        const diagnosticFileCount = diagnostics.length;
+        const elapsedTime = duration.getDurationInSeconds();
+
+        // Report any diagnostics or completion.
+        if (diagnosticFileCount > 0 || !moreToAnalyze) {
+            callback({
+                diagnostics,
+                filesInProgram: program.getFileCount(),
+                filesRequiringAnalysis: filesLeftToAnalyze,
+                checkingOnlyOpenFiles: program.isCheckingOnlyOpenFiles(),
+                fatalErrorOccurred: false,
+                configParseErrorOccurred: false,
+                elapsedTime,
+            });
+        }
+    } catch (e: any) {
+        if (OperationCanceledException.is(e)) {
+            return false;
+        }
+
+        const message = debug.getErrorString(e);
+        console.error('Error performing analysis: ' + message);
+
+        callback({
+            diagnostics: [],
+            filesInProgram: 0,
+            filesRequiringAnalysis: 0,
+            checkingOnlyOpenFiles: true,
+            fatalErrorOccurred: true,
+            configParseErrorOccurred: false,
+            elapsedTime: 0,
+            error: debug.getSerializableError(e),
+        });
+    }
+
+    return moreToAnalyze;
+}

package/src/analyzer/analyzerFileInfo.ts

@@ -0,0 +1,56 @@
+/*
+ * analyzerFileInfo.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Information associated with a source file that is used
+ * by the binder and checker.
+ */
+
+import { DiagnosticRuleSet, ExecutionEnvironment } from '../common/configOptions';
+import { TextRangeDiagnosticSink } from '../common/diagnosticSink';
+import { TextRange } from '../common/textRange';
+import { TextRangeCollection } from '../common/textRangeCollection';
+import { Scope } from './scope';
+import { SymbolTable } from './symbol';
+
+// Maps import paths to the symbol table for the imported module.
+export interface AbsoluteModuleDescriptor {
+    importingFilePath: string;
+    nameParts: string[];
+}
+export type ImportLookup = (filePathOrModule: string | AbsoluteModuleDescriptor) => ImportLookupResult | undefined;
+
+export interface ImportLookupResult {
+    symbolTable: SymbolTable;
+    dunderAllNames: string[] | undefined;
+    usesUnsupportedDunderAllForm: boolean;
+    docString: string | undefined;
+}
+
+export interface AnalyzerFileInfo {
+    importLookup: ImportLookup;
+    futureImports: Map<string, boolean>;
+    builtinsScope?: Scope | undefined;
+    diagnosticSink: TextRangeDiagnosticSink;
+    executionEnvironment: ExecutionEnvironment;
+    diagnosticRuleSet: DiagnosticRuleSet;
+    fileContents: string;
+    lines: TextRangeCollection<TextRange>;
+    typingSymbolAliases: Map<string, string>;
+    definedConstants: Map<string, boolean | string>;
+    filePath: string;
+    moduleName: string;
+    isStubFile: boolean;
+    isTypingStubFile: boolean;
+    isTypingExtensionsStubFile: boolean;
+    isBuiltInStubFile: boolean;
+    isInPyTypedPackage: boolean;
+    isIPythonMode: boolean;
+    accessedSymbolMap: Map<number, true>;
+}
+
+export function isAnnotationEvaluationPostponed(fileInfo: AnalyzerFileInfo) {
+    return fileInfo.futureImports.get('annotations') !== undefined || fileInfo.isStubFile;
+}

package/src/analyzer/analyzerNodeInfo.ts

@@ -0,0 +1,198 @@
+/*
+ * analyzerNodeInfo.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Defines objects that hang off the parse nodes in the parse tree.
+ * It contains information collected during the binder phase that
+ * can be used for later analysis steps or for language services
+ * (e.g. hover information).
+ */
+
+import {
+    ClassNode,
+    ExecutionScopeNode,
+    FunctionNode,
+    LambdaNode,
+    ListComprehensionNode,
+    ModuleNode,
+    ParseNode,
+    ParseNodeType,
+    StringNode,
+} from '../parser/parseNodes';
+import { AnalyzerFileInfo } from './analyzerFileInfo';
+import { FlowFlags, FlowNode } from './codeFlowTypes';
+import { Declaration } from './declaration';
+import { ImportResult } from './importResult';
+import { Scope } from './scope';
+
+export interface DunderAllInfo {
+    names: string[];
+    stringNodes: StringNode[];
+    usesUnsupportedDunderAllForm: boolean;
+}
+
+interface AnalyzerNodeInfo {
+    //---------------------------------------------------------------
+    // Set as part of import resolution
+
+    // Information about an import; used for import nodes only.
+    importInfo?: ImportResult;
+
+    //---------------------------------------------------------------
+    // Set by Binder
+
+    // Scope for nodes that introduce scopes: modules, functions,
+    // classes, lambdas, and list comprehensions. A scope is used
+    // to store symbol names and their associated types and declarations.
+    scope?: Scope;
+
+    // Declaration (for functions and classes only).
+    declaration?: Declaration;
+
+    // Control flow information for this node.
+    flowNode?: FlowNode;
+
+    // Control flow information at the end of this node.
+    afterFlowNode?: FlowNode;
+
+    // Info about the source file, used only on module nodes.
+    fileInfo?: AnalyzerFileInfo;
+
+    // Set of expressions used within an execution scope (module,
+    // function or lambda) that requires code flow analysis.
+    codeFlowExpressions?: Set<string>;
+
+    // Number that represents the complexity of a function's code
+    // flow graph.
+    codeFlowComplexity?: number;
+
+    // List of __all__ symbols in the module.
+    dunderAllInfo?: DunderAllInfo | undefined;
+}
+
+export type ScopedNode = ModuleNode | ClassNode | FunctionNode | LambdaNode | ListComprehensionNode;
+
+// Cleans out all fields that are added by the analyzer phases
+// (after the post-parse walker).
+export function cleanNodeAnalysisInfo(node: ParseNode) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    delete analyzerNode.scope;
+    delete analyzerNode.declaration;
+    delete analyzerNode.flowNode;
+    delete analyzerNode.afterFlowNode;
+    delete analyzerNode.fileInfo;
+    delete analyzerNode.codeFlowExpressions;
+    delete analyzerNode.codeFlowComplexity;
+    delete analyzerNode.dunderAllInfo;
+}
+
+export function getImportInfo(node: ParseNode): ImportResult | undefined {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    return analyzerNode.importInfo;
+}
+
+export function setImportInfo(node: ParseNode, importInfo: ImportResult) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    analyzerNode.importInfo = importInfo;
+}
+
+export function getScope(node: ParseNode): Scope | undefined {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    return analyzerNode.scope;
+}
+
+export function setScope(node: ParseNode, scope: Scope) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    analyzerNode.scope = scope;
+}
+
+export function getDeclaration(node: ParseNode): Declaration | undefined {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    return analyzerNode.declaration;
+}
+
+export function setDeclaration(node: ParseNode, decl: Declaration) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    analyzerNode.declaration = decl;
+}
+
+export function getFlowNode(node: ParseNode): FlowNode | undefined {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    return analyzerNode.flowNode;
+}
+
+export function setFlowNode(node: ParseNode, flowNode: FlowNode) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    analyzerNode.flowNode = flowNode;
+}
+
+export function getAfterFlowNode(node: ParseNode): FlowNode | undefined {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    return analyzerNode.afterFlowNode;
+}
+
+export function setAfterFlowNode(node: ParseNode, flowNode: FlowNode) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    analyzerNode.afterFlowNode = flowNode;
+}
+
+export function getFileInfo(node: ParseNode): AnalyzerFileInfo {
+    while (node.nodeType !== ParseNodeType.Module) {
+        node = node.parent!;
+    }
+    const analyzerNode = node as AnalyzerNodeInfo;
+    return analyzerNode.fileInfo!;
+}
+
+export function setFileInfo(node: ModuleNode, fileInfo: AnalyzerFileInfo) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    analyzerNode.fileInfo = fileInfo;
+}
+
+export function getCodeFlowExpressions(node: ExecutionScopeNode): Set<string> | undefined {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    return analyzerNode.codeFlowExpressions;
+}
+
+export function setCodeFlowExpressions(node: ExecutionScopeNode, expressions: Set<string>) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    analyzerNode.codeFlowExpressions = expressions;
+}
+
+export function getCodeFlowComplexity(node: ExecutionScopeNode) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    return analyzerNode.codeFlowComplexity ?? 0;
+}
+
+export function setCodeFlowComplexity(node: ExecutionScopeNode, complexity: number) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    analyzerNode.codeFlowComplexity = complexity;
+}
+
+export function getDunderAllInfo(node: ModuleNode): DunderAllInfo | undefined {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    return analyzerNode.dunderAllInfo;
+}
+
+export function setDunderAllInfo(node: ModuleNode, names: DunderAllInfo | undefined) {
+    const analyzerNode = node as AnalyzerNodeInfo;
+    analyzerNode.dunderAllInfo = names;
+}
+
+export function isCodeUnreachable(node: ParseNode): boolean {
+    let curNode: ParseNode | undefined = node;
+
+    // Walk up the parse tree until we find a node with
+    // an associated flow node.
+    while (curNode) {
+        const flowNode = getFlowNode(curNode);
+        if (flowNode) {
+            return !!(flowNode.flags & FlowFlags.Unreachable);
+        }
+        curNode = curNode.parent;
+    }
+
+    return false;
+}