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

package/src/analyzer/aliasDeclarationUtils.ts

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

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

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

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