@zzzen/pyright-internal 1.1.254

package/dist/analyzer/aliasDeclarationUtils.d.ts

@@ -0,0 +1,9 @@
+import { ImportLookup } from './analyzerFileInfo';
+import { Declaration } from './declaration';
+export interface ResolvedAliasInfo {
+    declaration: Declaration | undefined;
+    isPrivate: boolean;
+    privatePyTypedImported?: string;
+    privatePyTypedImporter?: string;
+}
+export declare function resolveAliasDeclaration(importLookup: ImportLookup, declaration: Declaration, resolveLocalNames: boolean, allowExternallyHiddenAccess: boolean): ResolvedAliasInfo | undefined;

package/dist/analyzer/aliasDeclarationUtils.js

@@ -0,0 +1,128 @@
+"use strict";
+/*
+ * aliasDeclarationUtils.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Helper functions around alias declarations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAliasDeclaration = void 0;
+// 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).
+function resolveAliasDeclaration(importLookup, declaration, resolveLocalNames, allowExternallyHiddenAccess) {
+    let curDeclaration = declaration;
+    const alreadyVisited = [];
+    let isPrivate = false;
+    let isPrivatePyTypedImport = false;
+    let privatePyTypedImported;
+    let privatePyTypedImporter;
+    while (true) {
+        if (curDeclaration.type !== 6 /* 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;
+        if (curDeclaration.path && curDeclaration.loadSymbolsFromPath) {
+            lookupResult = importLookup(curDeclaration.path);
+        }
+        const symbol = 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 !== null && privatePyTypedImported !== void 0 ? privatePyTypedImported : curDeclaration === null || curDeclaration === void 0 ? void 0 : curDeclaration.moduleName;
+        }
+        if (symbol.isPrivatePyTypedImport()) {
+            isPrivatePyTypedImport = true;
+        }
+        if (isPrivatePyTypedImport) {
+            privatePyTypedImporter = privatePyTypedImporter !== null && privatePyTypedImporter !== void 0 ? privatePyTypedImporter : curDeclaration === null || curDeclaration === void 0 ? void 0 : 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 === 6 /* Alias */ &&
+                curDeclaration.submoduleFallback) {
+                return resolveAliasDeclaration(importLookup, curDeclaration.submoduleFallback, resolveLocalNames, allowExternallyHiddenAccess);
+            }
+            return {
+                declaration,
+                isPrivate,
+                privatePyTypedImported,
+                privatePyTypedImporter,
+            };
+        }
+        alreadyVisited.push(curDeclaration);
+    }
+}
+exports.resolveAliasDeclaration = resolveAliasDeclaration;
+//# sourceMappingURL=aliasDeclarationUtils.js.map

package/dist/analyzer/aliasDeclarationUtils.js.map

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

package/dist/analyzer/analysis.d.ts

@@ -0,0 +1,18 @@
+import { CancellationToken } from 'vscode-languageserver';
+import { ConfigOptions } from '../common/configOptions';
+import { ConsoleInterface } from '../common/console';
+import { FileDiagnostics } from '../common/diagnosticSink';
+import { MaxAnalysisTime, Program } from './program';
+export declare const nullCallback: AnalysisCompleteCallback;
+export interface AnalysisResults {
+    diagnostics: FileDiagnostics[];
+    filesInProgram: number;
+    checkingOnlyOpenFiles: boolean;
+    filesRequiringAnalysis: number;
+    fatalErrorOccurred: boolean;
+    configParseErrorOccurred: boolean;
+    elapsedTime: number;
+    error?: Error | undefined;
+}
+export declare type AnalysisCompleteCallback = (results: AnalysisResults) => void;
+export declare function analyzeProgram(program: Program, maxTime: MaxAnalysisTime | undefined, configOptions: ConfigOptions, callback: AnalysisCompleteCallback | undefined, console: ConsoleInterface, token: CancellationToken): boolean;

package/dist/analyzer/analysis.js

@@ -0,0 +1,81 @@
+"use strict";
+/*
+ * analysis.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Various analysis helper types and functions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeProgram = exports.nullCallback = void 0;
+const cancellationUtils_1 = require("../common/cancellationUtils");
+const debug = __importStar(require("../common/debug"));
+const timing_1 = require("../common/timing");
+const nullCallback = (_) => {
+    /* empty */
+};
+exports.nullCallback = nullCallback;
+function analyzeProgram(program, maxTime, configOptions, callback, console, token) {
+    let moreToAnalyze = false;
+    callback = callback !== null && callback !== void 0 ? callback : exports.nullCallback;
+    try {
+        (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+        const duration = new timing_1.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) {
+        if (cancellationUtils_1.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;
+}
+exports.analyzeProgram = analyzeProgram;
+//# sourceMappingURL=analysis.js.map

package/dist/analyzer/analysis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.js","sourceRoot":"","sources":["../../../src/analyzer/analysis.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;AAIH,mEAAuG;AAGvG,uDAAyC;AAEzC,6CAA4C;AAGrC,MAAM,YAAY,GAA6B,CAAC,CAAC,EAAE,EAAE;IACxD,WAAW;AACf,CAAC,CAAC;AAFW,QAAA,YAAY,gBAEvB;AAeF,SAAgB,cAAc,CAC1B,OAAgB,EAChB,OAAoC,EACpC,aAA4B,EAC5B,QAA8C,EAC9C,OAAyB,EACzB,KAAwB;IAExB,IAAI,aAAa,GAAG,KAAK,CAAC;IAE1B,QAAQ,GAAG,QAAQ,aAAR,QAAQ,cAAR,QAAQ,GAAI,oBAAY,CAAC;IAEpC,IAAI;QACA,IAAA,gDAA4B,EAAC,KAAK,CAAC,CAAC;QAEpC,MAAM,QAAQ,GAAG,IAAI,iBAAQ,EAAE,CAAC;QAChC,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAEhD,MAAM,kBAAkB,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC;QAC5D,MAAM,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;QAC1D,MAAM,mBAAmB,GAAG,WAAW,CAAC,MAAM,CAAC;QAC/C,MAAM,WAAW,GAAG,QAAQ,CAAC,oBAAoB,EAAE,CAAC;QAEpD,wCAAwC;QACxC,IAAI,mBAAmB,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE;YAC3C,QAAQ,CAAC;gBACL,WAAW;gBACX,cAAc,EAAE,OAAO,CAAC,YAAY,EAAE;gBACtC,sBAAsB,EAAE,kBAAkB;gBAC1C,qBAAqB,EAAE,OAAO,CAAC,uBAAuB,EAAE;gBACxD,kBAAkB,EAAE,KAAK;gBACzB,wBAAwB,EAAE,KAAK;gBAC/B,WAAW;aACd,CAAC,CAAC;SACN;KACJ;IAAC,OAAO,CAAM,EAAE;QACb,IAAI,8CAA0B,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE;YAClC,OAAO,KAAK,CAAC;SAChB;QAED,MAAM,OAAO,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;QACxC,OAAO,CAAC,KAAK,CAAC,6BAA6B,GAAG,OAAO,CAAC,CAAC;QAEvD,QAAQ,CAAC;YACL,WAAW,EAAE,EAAE;YACf,cAAc,EAAE,CAAC;YACjB,sBAAsB,EAAE,CAAC;YACzB,qBAAqB,EAAE,IAAI;YAC3B,kBAAkB,EAAE,IAAI;YACxB,wBAAwB,EAAE,KAAK;YAC/B,WAAW,EAAE,CAAC;YACd,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC;SACvC,CAAC,CAAC;KACN;IAED,OAAO,aAAa,CAAC;AACzB,CAAC;AAxDD,wCAwDC"}

package/dist/analyzer/analyzerFileInfo.d.ts

@@ -0,0 +1,39 @@
+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';
+export interface AbsoluteModuleDescriptor {
+    importingFilePath: string;
+    nameParts: string[];
+}
+export declare 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 declare function isAnnotationEvaluationPostponed(fileInfo: AnalyzerFileInfo): boolean;

package/dist/analyzer/analyzerFileInfo.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnnotationEvaluationPostponed = void 0;
+function isAnnotationEvaluationPostponed(fileInfo) {
+    return fileInfo.futureImports.get('annotations') !== undefined || fileInfo.isStubFile;
+}
+exports.isAnnotationEvaluationPostponed = isAnnotationEvaluationPostponed;
+//# sourceMappingURL=analyzerFileInfo.js.map

package/dist/analyzer/analyzerFileInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzerFileInfo.js","sourceRoot":"","sources":["../../../src/analyzer/analyzerFileInfo.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AA6CH,SAAgB,+BAA+B,CAAC,QAA0B;IACtE,OAAO,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,SAAS,IAAI,QAAQ,CAAC,UAAU,CAAC;AAC1F,CAAC;AAFD,0EAEC"}

package/dist/analyzer/analyzerNodeInfo.d.ts

@@ -0,0 +1,32 @@
+import { ClassNode, ExecutionScopeNode, FunctionNode, LambdaNode, ListComprehensionNode, ModuleNode, ParseNode, StringNode } from '../parser/parseNodes';
+import { AnalyzerFileInfo } from './analyzerFileInfo';
+import { FlowNode } from './codeFlowTypes';
+import { Declaration } from './declaration';
+import { ImportResult } from './importResult';
+import { Scope } from './scope';
+export interface DunderAllInfo {
+    names: string[];
+    stringNodes: StringNode[];
+    usesUnsupportedDunderAllForm: boolean;
+}
+export declare type ScopedNode = ModuleNode | ClassNode | FunctionNode | LambdaNode | ListComprehensionNode;
+export declare function cleanNodeAnalysisInfo(node: ParseNode): void;
+export declare function getImportInfo(node: ParseNode): ImportResult | undefined;
+export declare function setImportInfo(node: ParseNode, importInfo: ImportResult): void;
+export declare function getScope(node: ParseNode): Scope | undefined;
+export declare function setScope(node: ParseNode, scope: Scope): void;
+export declare function getDeclaration(node: ParseNode): Declaration | undefined;
+export declare function setDeclaration(node: ParseNode, decl: Declaration): void;
+export declare function getFlowNode(node: ParseNode): FlowNode | undefined;
+export declare function setFlowNode(node: ParseNode, flowNode: FlowNode): void;
+export declare function getAfterFlowNode(node: ParseNode): FlowNode | undefined;
+export declare function setAfterFlowNode(node: ParseNode, flowNode: FlowNode): void;
+export declare function getFileInfo(node: ParseNode): AnalyzerFileInfo;
+export declare function setFileInfo(node: ModuleNode, fileInfo: AnalyzerFileInfo): void;
+export declare function getCodeFlowExpressions(node: ExecutionScopeNode): Set<string> | undefined;
+export declare function setCodeFlowExpressions(node: ExecutionScopeNode, expressions: Set<string>): void;
+export declare function getCodeFlowComplexity(node: ExecutionScopeNode): number;
+export declare function setCodeFlowComplexity(node: ExecutionScopeNode, complexity: number): void;
+export declare function getDunderAllInfo(node: ModuleNode): DunderAllInfo | undefined;
+export declare function setDunderAllInfo(node: ModuleNode, names: DunderAllInfo | undefined): void;
+export declare function isCodeUnreachable(node: ParseNode): boolean;

package/dist/analyzer/analyzerNodeInfo.js

@@ -0,0 +1,138 @@
+"use strict";
+/*
+ * 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).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCodeUnreachable = exports.setDunderAllInfo = exports.getDunderAllInfo = exports.setCodeFlowComplexity = exports.getCodeFlowComplexity = exports.setCodeFlowExpressions = exports.getCodeFlowExpressions = exports.setFileInfo = exports.getFileInfo = exports.setAfterFlowNode = exports.getAfterFlowNode = exports.setFlowNode = exports.getFlowNode = exports.setDeclaration = exports.getDeclaration = exports.setScope = exports.getScope = exports.setImportInfo = exports.getImportInfo = exports.cleanNodeAnalysisInfo = void 0;
+const codeFlowTypes_1 = require("./codeFlowTypes");
+// Cleans out all fields that are added by the analyzer phases
+// (after the post-parse walker).
+function cleanNodeAnalysisInfo(node) {
+    const analyzerNode = node;
+    delete analyzerNode.scope;
+    delete analyzerNode.declaration;
+    delete analyzerNode.flowNode;
+    delete analyzerNode.afterFlowNode;
+    delete analyzerNode.fileInfo;
+    delete analyzerNode.codeFlowExpressions;
+    delete analyzerNode.codeFlowComplexity;
+    delete analyzerNode.dunderAllInfo;
+}
+exports.cleanNodeAnalysisInfo = cleanNodeAnalysisInfo;
+function getImportInfo(node) {
+    const analyzerNode = node;
+    return analyzerNode.importInfo;
+}
+exports.getImportInfo = getImportInfo;
+function setImportInfo(node, importInfo) {
+    const analyzerNode = node;
+    analyzerNode.importInfo = importInfo;
+}
+exports.setImportInfo = setImportInfo;
+function getScope(node) {
+    const analyzerNode = node;
+    return analyzerNode.scope;
+}
+exports.getScope = getScope;
+function setScope(node, scope) {
+    const analyzerNode = node;
+    analyzerNode.scope = scope;
+}
+exports.setScope = setScope;
+function getDeclaration(node) {
+    const analyzerNode = node;
+    return analyzerNode.declaration;
+}
+exports.getDeclaration = getDeclaration;
+function setDeclaration(node, decl) {
+    const analyzerNode = node;
+    analyzerNode.declaration = decl;
+}
+exports.setDeclaration = setDeclaration;
+function getFlowNode(node) {
+    const analyzerNode = node;
+    return analyzerNode.flowNode;
+}
+exports.getFlowNode = getFlowNode;
+function setFlowNode(node, flowNode) {
+    const analyzerNode = node;
+    analyzerNode.flowNode = flowNode;
+}
+exports.setFlowNode = setFlowNode;
+function getAfterFlowNode(node) {
+    const analyzerNode = node;
+    return analyzerNode.afterFlowNode;
+}
+exports.getAfterFlowNode = getAfterFlowNode;
+function setAfterFlowNode(node, flowNode) {
+    const analyzerNode = node;
+    analyzerNode.afterFlowNode = flowNode;
+}
+exports.setAfterFlowNode = setAfterFlowNode;
+function getFileInfo(node) {
+    while (node.nodeType !== 36 /* Module */) {
+        node = node.parent;
+    }
+    const analyzerNode = node;
+    return analyzerNode.fileInfo;
+}
+exports.getFileInfo = getFileInfo;
+function setFileInfo(node, fileInfo) {
+    const analyzerNode = node;
+    analyzerNode.fileInfo = fileInfo;
+}
+exports.setFileInfo = setFileInfo;
+function getCodeFlowExpressions(node) {
+    const analyzerNode = node;
+    return analyzerNode.codeFlowExpressions;
+}
+exports.getCodeFlowExpressions = getCodeFlowExpressions;
+function setCodeFlowExpressions(node, expressions) {
+    const analyzerNode = node;
+    analyzerNode.codeFlowExpressions = expressions;
+}
+exports.setCodeFlowExpressions = setCodeFlowExpressions;
+function getCodeFlowComplexity(node) {
+    var _a;
+    const analyzerNode = node;
+    return (_a = analyzerNode.codeFlowComplexity) !== null && _a !== void 0 ? _a : 0;
+}
+exports.getCodeFlowComplexity = getCodeFlowComplexity;
+function setCodeFlowComplexity(node, complexity) {
+    const analyzerNode = node;
+    analyzerNode.codeFlowComplexity = complexity;
+}
+exports.setCodeFlowComplexity = setCodeFlowComplexity;
+function getDunderAllInfo(node) {
+    const analyzerNode = node;
+    return analyzerNode.dunderAllInfo;
+}
+exports.getDunderAllInfo = getDunderAllInfo;
+function setDunderAllInfo(node, names) {
+    const analyzerNode = node;
+    analyzerNode.dunderAllInfo = names;
+}
+exports.setDunderAllInfo = setDunderAllInfo;
+function isCodeUnreachable(node) {
+    let curNode = 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 & codeFlowTypes_1.FlowFlags.Unreachable);
+        }
+        curNode = curNode.parent;
+    }
+    return false;
+}
+exports.isCodeUnreachable = isCodeUnreachable;
+//# sourceMappingURL=analyzerNodeInfo.js.map

package/dist/analyzer/analyzerNodeInfo.js.map

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

package/dist/analyzer/backgroundAnalysisProgram.d.ts

@@ -0,0 +1,54 @@
+import { CancellationToken } from 'vscode-languageserver';
+import { TextDocumentContentChangeEvent } from 'vscode-languageserver-textdocument';
+import { BackgroundAnalysisBase, IndexOptions } from '../backgroundAnalysisBase';
+import { ConfigOptions } from '../common/configOptions';
+import { ConsoleInterface } from '../common/console';
+import { Diagnostic } from '../common/diagnostic';
+import { LanguageServiceExtension } from '../common/extensibility';
+import { Range } from '../common/textRange';
+import { IndexResults } from '../languageService/documentSymbolProvider';
+import { AnalysisCompleteCallback } from './analysis';
+import { ImportResolver } from './importResolver';
+import { MaxAnalysisTime, OpenFileOptions, Program } from './program';
+export declare class BackgroundAnalysisProgram {
+    private _console;
+    private _configOptions;
+    private _importResolver;
+    private _backgroundAnalysis?;
+    private _maxAnalysisTime?;
+    private _disableChecker?;
+    private _program;
+    private _onAnalysisCompletion;
+    private _indices;
+    constructor(_console: ConsoleInterface, _configOptions: ConfigOptions, _importResolver: ImportResolver, extension?: LanguageServiceExtension, _backgroundAnalysis?: BackgroundAnalysisBase | undefined, _maxAnalysisTime?: MaxAnalysisTime | undefined, _disableChecker?: boolean | undefined);
+    get configOptions(): ConfigOptions;
+    get importResolver(): ImportResolver;
+    get program(): Program;
+    get host(): import("../common/host").Host;
+    get backgroundAnalysis(): BackgroundAnalysisBase | undefined;
+    setConfigOptions(configOptions: ConfigOptions): void;
+    setImportResolver(importResolver: ImportResolver): void;
+    setTrackedFiles(filePaths: string[]): void;
+    setAllowedThirdPartyImports(importNames: string[]): void;
+    setFileOpened(filePath: string, version: number | null, contents: string, options: OpenFileOptions): void;
+    updateChainedFilePath(filePath: string, chainedFilePath: string | undefined): void;
+    updateOpenFileContents(path: string, version: number | null, contents: TextDocumentContentChangeEvent[], options: OpenFileOptions): void;
+    setFileClosed(filePath: string): void;
+    markAllFilesDirty(evenIfContentsAreSame: boolean, indexingNeeded?: boolean): void;
+    markFilesDirty(filePaths: string[], evenIfContentsAreSame: boolean, indexingNeeded?: boolean): void;
+    setCompletionCallback(callback?: AnalysisCompleteCallback): void;
+    startAnalysis(token: CancellationToken): boolean;
+    test_setIndexing(workspaceIndices: Map<string, IndexResults>, libraryIndices: Map<string | undefined, Map<string, IndexResults>>): void;
+    startIndexing(indexOptions: IndexOptions): void;
+    refreshIndexing(): void;
+    cancelIndexing(): void;
+    getIndexing(filePath: string): Map<string, IndexResults> | undefined;
+    getDiagnosticsForRange(filePath: string, range: Range, token: CancellationToken): Promise<Diagnostic[]>;
+    writeTypeStub(targetImportPath: string, targetIsSingleFile: boolean, stubPath: string, token: CancellationToken): Promise<any>;
+    invalidateAndForceReanalysis(rebuildUserFileIndexing: boolean, rebuildLibraryIndexing: boolean): void;
+    restart(): void;
+    private _ensurePartialStubPackages;
+    private _getIndices;
+    private _reportDiagnosticsForRemovedFiles;
+}
+export declare type BackgroundAnalysisProgramFactory = (console: ConsoleInterface, configOptions: ConfigOptions, importResolver: ImportResolver, extension?: LanguageServiceExtension, backgroundAnalysis?: BackgroundAnalysisBase, maxAnalysisTime?: MaxAnalysisTime) => BackgroundAnalysisProgram;