@zzzen/pyright-internal 1.1.254

package/dist/analyzer/packageTypeVerifier.js

@@ -0,0 +1,908 @@
+"use strict";
+/*
+ * packageTypeVerifier.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Validates the public symbols exported by a package to ensure
+ * that the types are complete.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageTypeVerifier = void 0;
+const configOptions_1 = require("../common/configOptions");
+const debug_1 = require("../common/debug");
+const diagnostic_1 = require("../common/diagnostic");
+const fullAccessHost_1 = require("../common/fullAccessHost");
+const pathUtils_1 = require("../common/pathUtils");
+const textRange_1 = require("../common/textRange");
+const importResolver_1 = require("./importResolver");
+const packageTypeReport_1 = require("./packageTypeReport");
+const program_1 = require("./program");
+const pyTypedUtils_1 = require("./pyTypedUtils");
+const scopeUtils_1 = require("./scopeUtils");
+const symbolNameUtils_1 = require("./symbolNameUtils");
+const types_1 = require("./types");
+const typeUtils_1 = require("./typeUtils");
+class PackageTypeVerifier {
+    constructor(_fileSystem, _packageName, _ignoreExternal = false) {
+        this._fileSystem = _fileSystem;
+        this._packageName = _packageName;
+        this._ignoreExternal = _ignoreExternal;
+        this._configOptions = new configOptions_1.ConfigOptions('');
+        if (_ignoreExternal) {
+            this._configOptions.evaluateUnknownImportsAsAny = true;
+        }
+        this._execEnv = this._configOptions.findExecEnvironment('.');
+        this._importResolver = new importResolver_1.ImportResolver(this._fileSystem, this._configOptions, new fullAccessHost_1.FullAccessHost(this._fileSystem));
+        this._program = new program_1.Program(this._importResolver, this._configOptions);
+    }
+    verify() {
+        var _a, _b;
+        const trimmedModuleName = this._packageName.trim();
+        const moduleNameParts = trimmedModuleName.split('.');
+        const report = (0, packageTypeReport_1.getEmptyReport)(moduleNameParts[0], (_a = this._getDirectoryForModule(moduleNameParts[0])) !== null && _a !== void 0 ? _a : '', trimmedModuleName, (_b = this._getDirectoryForModule(trimmedModuleName)) !== null && _b !== void 0 ? _b : '', this._ignoreExternal);
+        const commonDiagnostics = report.generalDiagnostics;
+        try {
+            if (!trimmedModuleName) {
+                commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `Module name "${trimmedModuleName}" is invalid`, (0, textRange_1.getEmptyRange)()));
+            }
+            else if (!report.moduleRootDirectory) {
+                commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `Module "${trimmedModuleName}" cannot be resolved`, (0, textRange_1.getEmptyRange)()));
+            }
+            else {
+                let pyTypedInfo;
+                if (report.moduleRootDirectory) {
+                    pyTypedInfo = this._getDeepestPyTypedInfo(report.moduleRootDirectory, moduleNameParts);
+                }
+                // If we couldn't find any "py.typed" info in the module path, search again
+                // starting at the package root.
+                if (!pyTypedInfo && report.packageRootDirectory) {
+                    pyTypedInfo = this._getDeepestPyTypedInfo(report.packageRootDirectory, moduleNameParts);
+                }
+                if (!pyTypedInfo) {
+                    commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, 'No py.typed file found', (0, textRange_1.getEmptyRange)()));
+                }
+                else {
+                    report.pyTypedPath = pyTypedInfo.pyTypedPath;
+                    const publicModules = this._getListOfPublicModules(report.moduleRootDirectory, trimmedModuleName);
+                    // If the filter eliminated all modules, report an error.
+                    if (publicModules.length === 0) {
+                        commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `Module "${trimmedModuleName}" cannot be resolved`, (0, textRange_1.getEmptyRange)()));
+                    }
+                    // Build a map of all public symbols exported by this package. We'll
+                    // use this map to determine which diagnostics to report. We don't want
+                    // to report diagnostics many times for types that include public types.
+                    const publicSymbolMap = new Map();
+                    publicModules.forEach((moduleName) => {
+                        this._getPublicSymbolsForModule(moduleName, publicSymbolMap, report.alternateSymbolNames);
+                    });
+                    publicModules.forEach((moduleName) => {
+                        this._verifyTypesOfModule(moduleName, publicSymbolMap, report);
+                    });
+                }
+            }
+        }
+        catch (e) {
+            const message = (e.stack ? e.stack.toString() : undefined) ||
+                (typeof e.message === 'string' ? e.message : undefined) ||
+                JSON.stringify(e);
+            commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `An internal error occurred while verifying types: "${message}"`, (0, textRange_1.getEmptyRange)()));
+        }
+        return report;
+    }
+    static getSymbolCategoryString(symbolType) {
+        switch (symbolType) {
+            case packageTypeReport_1.SymbolCategory.Class:
+                return 'class';
+            case packageTypeReport_1.SymbolCategory.Function:
+                return 'function';
+            case packageTypeReport_1.SymbolCategory.Method:
+                return 'method';
+            case packageTypeReport_1.SymbolCategory.Constant:
+                return 'constant';
+            case packageTypeReport_1.SymbolCategory.Variable:
+                return 'variable';
+            case packageTypeReport_1.SymbolCategory.Module:
+                return 'module';
+            case packageTypeReport_1.SymbolCategory.TypeAlias:
+                return 'type alias';
+            case packageTypeReport_1.SymbolCategory.TypeVar:
+                return 'type variable';
+            case packageTypeReport_1.SymbolCategory.Indeterminate:
+                return 'symbol';
+        }
+    }
+    _getDeepestPyTypedInfo(rootDirectory, packageNameParts) {
+        let subNameParts = [...packageNameParts];
+        // Find the deepest py.typed file that corresponds to the requested submodule.
+        while (subNameParts.length >= 1) {
+            const packageSubdir = (0, pathUtils_1.combinePaths)(rootDirectory, ...subNameParts.slice(1));
+            const pyTypedInfo = (0, pyTypedUtils_1.getPyTypedInfo)(this._fileSystem, packageSubdir);
+            if (pyTypedInfo) {
+                return pyTypedInfo;
+            }
+            subNameParts = subNameParts.slice(0, subNameParts.length - 1);
+        }
+        return undefined;
+    }
+    _resolveImport(moduleName) {
+        return this._importResolver.resolveImport('', this._execEnv, (0, importResolver_1.createImportedModuleDescriptor)(moduleName));
+    }
+    _getPublicSymbolsForModule(moduleName, symbolMap, alternateSymbolNames) {
+        const importResult = this._resolveImport(moduleName);
+        if (importResult.isImportFound) {
+            const modulePath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
+            this._program.addTrackedFiles([modulePath], /* isThirdPartyImport */ true, /* isInPyTypedPackage */ true);
+            const sourceFile = this._program.getBoundSourceFile(modulePath);
+            if (sourceFile) {
+                const module = {
+                    name: moduleName,
+                    path: modulePath,
+                    isExported: true,
+                };
+                const parseTree = sourceFile.getParseResults().parseTree;
+                const moduleScope = (0, scopeUtils_1.getScopeForNode)(parseTree);
+                this._getPublicSymbolsInSymbolTable(symbolMap, alternateSymbolNames, module, module.name, moduleScope.symbolTable, 3 /* Module */);
+            }
+        }
+    }
+    _getPublicSymbolsInSymbolTable(symbolMap, alternateSymbolNames, module, scopeName, symbolTable, scopeType) {
+        symbolTable.forEach((symbol, name) => {
+            if (!(0, symbolNameUtils_1.isPrivateOrProtectedName)(name) &&
+                !symbol.isIgnoredForProtocolMatch() &&
+                !this._isSymbolTypeImplied(scopeType, name)) {
+                const fullName = `${scopeName}.${name}`;
+                if (!symbol.isExternallyHidden() && !symbol.isPrivateMember() && !symbol.isPrivatePyTypedImport()) {
+                    const symbolType = this._program.getTypeOfSymbol(symbol);
+                    symbolMap.set(fullName, fullName);
+                    const typedDecls = symbol.getTypedDeclarations();
+                    if (typedDecls.length > 0) {
+                        // Is this a class declared within this module or class?
+                        // If so, add the symbols declared within it.
+                        const classDecl = typedDecls.find((decl) => decl.type === 4 /* Class */);
+                        if (classDecl) {
+                            if ((0, types_1.isInstantiableClass)(symbolType)) {
+                                this._getPublicSymbolsInSymbolTable(symbolMap, alternateSymbolNames, module, fullName, symbolType.details.fields, 2 /* Class */);
+                            }
+                        }
+                    }
+                    // Is this the re-export of an import? If so, record the alternate name.
+                    const importDecl = symbol.getDeclarations().find((decl) => decl.type === 6 /* Alias */);
+                    if (importDecl && importDecl.type === 6 /* Alias */) {
+                        const typeName = (0, typeUtils_1.getFullNameOfType)(this._program.getTypeOfSymbol(symbol));
+                        if (typeName) {
+                            this._addAlternateSymbolName(alternateSymbolNames, typeName, fullName);
+                        }
+                    }
+                }
+            }
+        });
+    }
+    _addAlternateSymbolName(map, name, altName) {
+        if (name !== altName) {
+            let altNameList = map.get(name);
+            if (!altNameList) {
+                altNameList = [];
+                map.set(name, altNameList);
+            }
+            // Add the alternate name if it's unique.
+            if (!altNameList.some((name) => name === altName)) {
+                altNameList.push(altName);
+            }
+        }
+    }
+    _verifyTypesOfModule(moduleName, publicSymbolMap, report) {
+        const importResult = this._resolveImport(moduleName);
+        if (!importResult.isImportFound) {
+            report.generalDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `Could not resolve module "${moduleName}"`, (0, textRange_1.getEmptyRange)()));
+        }
+        else if (importResult.isStubPackage) {
+            report.generalDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `No inlined types found for module "${moduleName}" because stub package was present`, (0, textRange_1.getEmptyRange)()));
+        }
+        else {
+            const modulePath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
+            const module = {
+                name: moduleName,
+                path: modulePath,
+                isExported: true,
+            };
+            report.modules.set(modulePath, module);
+            this._program.addTrackedFiles([modulePath], /* isThirdPartyImport */ true, /* isInPyTypedPackage */ true);
+            const sourceFile = this._program.getBoundSourceFile(modulePath);
+            if (sourceFile) {
+                const parseTree = sourceFile.getParseResults().parseTree;
+                const moduleScope = (0, scopeUtils_1.getScopeForNode)(parseTree);
+                this._getTypeKnownStatusForSymbolTable(report, module.name, moduleScope.symbolTable, 3 /* Module */, publicSymbolMap);
+            }
+            else {
+                report.generalDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `Could not bind file "${modulePath}"`, (0, textRange_1.getEmptyRange)()));
+            }
+        }
+    }
+    // Scans the directory structure for a list of public modules
+    // within the package.
+    _getListOfPublicModules(moduleRootPath, moduleName) {
+        const publicModules = [];
+        this._addPublicModulesRecursive(moduleRootPath, moduleName, publicModules);
+        // Make sure modules are unique. There may be duplicates if a ".py" and ".pyi"
+        // exist for some modules.
+        const uniqueModules = [];
+        const moduleMap = new Map();
+        publicModules.forEach((module) => {
+            if (!moduleMap.has(module)) {
+                uniqueModules.push(module);
+                moduleMap.set(module, module);
+            }
+        });
+        return uniqueModules;
+    }
+    _addPublicModulesRecursive(dirPath, modulePath, publicModules) {
+        const dirEntries = this._fileSystem.readdirEntriesSync(dirPath);
+        dirEntries.forEach((entry) => {
+            let isFile = entry.isFile();
+            let isDirectory = entry.isDirectory();
+            if (entry.isSymbolicLink()) {
+                const stat = (0, pathUtils_1.tryStat)(this._fileSystem, (0, pathUtils_1.combinePaths)(dirPath, entry.name));
+                if (stat) {
+                    isFile = stat.isFile();
+                    isDirectory = stat.isDirectory();
+                }
+            }
+            if (isFile) {
+                const fileExtension = (0, pathUtils_1.getFileExtension)(entry.name);
+                if (fileExtension === '.py' || fileExtension === '.pyi') {
+                    const nameWithoutExtension = (0, pathUtils_1.stripFileExtension)(entry.name);
+                    if (nameWithoutExtension === '__init__') {
+                        publicModules.push(modulePath);
+                    }
+                    else {
+                        if (!(0, symbolNameUtils_1.isPrivateOrProtectedName)(nameWithoutExtension) &&
+                            this._isLegalModulePartName(nameWithoutExtension)) {
+                            publicModules.push(`${modulePath}.${nameWithoutExtension}`);
+                        }
+                    }
+                }
+            }
+            else if (isDirectory) {
+                if (!(0, symbolNameUtils_1.isPrivateOrProtectedName)(entry.name) && this._isLegalModulePartName(entry.name)) {
+                    this._addPublicModulesRecursive((0, pathUtils_1.combinePaths)(dirPath, entry.name), `${modulePath}.${entry.name}`, publicModules);
+                }
+            }
+        });
+    }
+    _isLegalModulePartName(name) {
+        // PEP8 indicates that all module names should be lowercase
+        // with underscores. It doesn't talk about non-ASCII
+        // characters, but it appears that's the convention.
+        return !!name.match(/[a-z_]+/);
+    }
+    _shouldIgnoreType(report, fullTypeName) {
+        // If we're ignoring unknown types from other packages, see if we should skip.
+        return report.ignoreExternal && !fullTypeName.startsWith(report.packageName);
+    }
+    _getTypeKnownStatusForSymbolTable(report, scopeName, symbolTable, scopeType, publicSymbolMap, overrideSymbolCallback) {
+        if (this._shouldIgnoreType(report, scopeName)) {
+            return 0 /* Known */;
+        }
+        let knownStatus = 0 /* Known */;
+        symbolTable.forEach((symbol, name) => {
+            if (!(0, symbolNameUtils_1.isPrivateOrProtectedName)(name) &&
+                !symbol.isExternallyHidden() &&
+                !symbol.isPrivateMember() &&
+                !symbol.isPrivatePyTypedImport() &&
+                !symbol.isIgnoredForProtocolMatch() &&
+                !this._isSymbolTypeImplied(scopeType, name)) {
+                const fullName = `${scopeName}.${name}`;
+                // If the symbol was already cached, update its reference count
+                // and skip the rest.
+                const cachedSymbolInfo = report.symbols.get(fullName);
+                if (cachedSymbolInfo) {
+                    cachedSymbolInfo.referenceCount++;
+                    return;
+                }
+                let symbolType = this._program.getTypeOfSymbol(symbol);
+                let usesAmbiguousOverride = false;
+                let baseSymbolType;
+                let childSymbolType;
+                if (overrideSymbolCallback) {
+                    const baseTypeSymbol = overrideSymbolCallback(name, symbol);
+                    if (baseTypeSymbol !== symbol) {
+                        childSymbolType = symbolType;
+                        baseSymbolType = this._program.getTypeOfSymbol(baseTypeSymbol);
+                        // If the inferred type is ambiguous or the declared base class type is
+                        // not the same type as the inferred type, mark it as ambiguous because
+                        // different type checkers will get different results.
+                        if (types_1.TypeBase.isAmbiguous(childSymbolType) || !(0, types_1.isTypeSame)(baseSymbolType, childSymbolType)) {
+                            // If the base type is known to be a descriptor with a setter,
+                            // assume that the child class is simply writing to the base class's setter.
+                            if (!(0, typeUtils_1.isDescriptorInstance)(baseSymbolType, /* requireSetter */ true)) {
+                                usesAmbiguousOverride = true;
+                            }
+                        }
+                        symbolType = baseSymbolType;
+                    }
+                }
+                const typedDecls = symbol.getTypedDeclarations();
+                const primaryDecl = typedDecls.length > 0 ? typedDecls[typedDecls.length - 1] : undefined;
+                let symbolInfo;
+                if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 4 /* Class */ && (0, types_1.isInstantiableClass)(symbolType)) {
+                    symbolInfo = this._getSymbolForClass(report, symbolType, publicSymbolMap);
+                }
+                else if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 6 /* Alias */ && (0, types_1.isModule)(symbolType)) {
+                    symbolInfo = this._getSymbolForModule(report, symbolType, publicSymbolMap);
+                }
+                else {
+                    const decls = symbol.getDeclarations();
+                    const primaryDecl = decls.length > 0 ? decls[decls.length - 1] : undefined;
+                    const declRange = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.range) || (0, textRange_1.getEmptyRange)();
+                    const declPath = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.path) || '';
+                    const symbolCategory = this._getSymbolCategory(symbol, symbolType);
+                    const isExported = publicSymbolMap.has(fullName);
+                    // If the only reference to this symbol is a "__slots__" entry, we will
+                    // skip it when considering type completeness.
+                    if (decls.length === 1 &&
+                        (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ &&
+                        primaryDecl.isDefinedBySlots) {
+                        return;
+                    }
+                    symbolInfo = {
+                        category: symbolCategory,
+                        name,
+                        fullName,
+                        filePath: module.path,
+                        isExported,
+                        typeKnownStatus: 0 /* Known */,
+                        referenceCount: 1,
+                        diagnostics: [],
+                        scopeType,
+                    };
+                    this._addSymbol(report, symbolInfo);
+                    if (!this._isSymbolTypeImplied(scopeType, name)) {
+                        this._getSymbolTypeKnownStatus(report, symbolInfo, symbolType, declRange, declPath, publicSymbolMap);
+                    }
+                }
+                if (usesAmbiguousOverride) {
+                    const decls = symbol.getDeclarations();
+                    const primaryDecl = decls.length > 0 ? decls[decls.length - 1] : undefined;
+                    const declRange = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.range) || (0, textRange_1.getEmptyRange)();
+                    const declPath = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.path) || '';
+                    const extraInfo = new diagnostic_1.DiagnosticAddendum();
+                    if (baseSymbolType) {
+                        extraInfo.addMessage(`Type declared in base class is "${this._program.printType(baseSymbolType, 
+                        /* expandTypeAlias */ false)}"`);
+                    }
+                    if (childSymbolType) {
+                        extraInfo.addMessage(`Type inferred in child class is "${this._program.printType(childSymbolType, 
+                        /* expandTypeAlias */ false)}"`);
+                        if (types_1.TypeBase.isAmbiguous(childSymbolType)) {
+                            extraInfo.addMessage('Inferred child class type is missing type annotation and could be inferred differently by type checkers');
+                        }
+                    }
+                    this._addSymbolError(symbolInfo, `Ambiguous base class override` + extraInfo.getString(), declRange, declPath);
+                    symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, 1 /* Ambiguous */);
+                }
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, symbolInfo.typeKnownStatus);
+            }
+        });
+        return knownStatus;
+    }
+    // Determines whether the type for the symbol in question is fully known.
+    // If not, it adds diagnostics to the symbol information and updates the
+    // typeKnownStatus field.
+    _getSymbolTypeKnownStatus(report, symbolInfo, type, declRange, declFilePath, publicSymbolMap) {
+        let knownStatus = 0 /* Known */;
+        if (type.typeAliasInfo && type.typeAliasInfo.typeArguments) {
+            type.typeAliasInfo.typeArguments.forEach((typeArg, index) => {
+                if ((0, types_1.isUnknown)(typeArg)) {
+                    this._addSymbolError(symbolInfo, `Type argument ${index + 1} for type alias "${type.typeAliasInfo.name}" has unknown type`, declRange, declFilePath);
+                    knownStatus = 3 /* Unknown */;
+                }
+                else if ((0, typeUtils_1.isPartlyUnknown)(typeArg)) {
+                    this._addSymbolError(symbolInfo, `Type argument ${index + 1} for type alias "${type.typeAliasInfo.name}" has partially unknown type`, declRange, declFilePath);
+                    knownStatus = 2 /* PartiallyUnknown */;
+                }
+            });
+        }
+        if (types_1.TypeBase.isAmbiguous(type) && !(0, types_1.isUnknown)(type)) {
+            const ambiguousDiag = new diagnostic_1.DiagnosticAddendum();
+            ambiguousDiag.addMessage(`Inferred type is "${this._program.printType(type, /* expandTypeAlias */ false)}"`);
+            this._addSymbolError(symbolInfo, 'Type is missing type annotation and could be inferred differently by type checkers' +
+                ambiguousDiag.getString(), declRange, declFilePath);
+            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 1 /* Ambiguous */);
+        }
+        switch (type.category) {
+            case 0 /* Unbound */:
+            case 2 /* Any */:
+            case 3 /* None */:
+            case 4 /* Never */:
+            case 10 /* TypeVar */:
+                break;
+            case 1 /* Unknown */: {
+                this._addSymbolError(symbolInfo, `Type unknown for ${PackageTypeVerifier.getSymbolCategoryString(symbolInfo.category)} "${symbolInfo.fullName}"`, declRange, declFilePath);
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                break;
+            }
+            case 9 /* Union */: {
+                (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getSymbolTypeKnownStatus(report, symbolInfo, subtype, declRange, declFilePath, publicSymbolMap));
+                });
+                break;
+            }
+            case 6 /* OverloadedFunction */: {
+                for (const overload of type.overloads) {
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getSymbolTypeKnownStatus(report, symbolInfo, overload, declRange, declFilePath, publicSymbolMap));
+                }
+                break;
+            }
+            case 5 /* Function */: {
+                if (!this._shouldIgnoreType(report, type.details.fullName)) {
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getFunctionTypeKnownStatus(report, type, publicSymbolMap, symbolInfo, declRange, declFilePath));
+                }
+                break;
+            }
+            case 7 /* Class */: {
+                // Properties require special handling.
+                if (types_1.TypeBase.isInstance(type) && types_1.ClassType.isPropertyClass(type)) {
+                    const accessors = ['fget', 'fset', 'fdel'];
+                    const propertyClass = type;
+                    accessors.forEach((accessorName) => {
+                        const accessSymbol = propertyClass.details.fields.get(accessorName);
+                        let accessType = accessSymbol ? this._program.getTypeOfSymbol(accessSymbol) : undefined;
+                        if (!accessType) {
+                            return;
+                        }
+                        if ((0, types_1.isFunction)(accessType)) {
+                            // The processing for fget, fset and fdel mark the methods as "static" so they
+                            // work properly when accessed directly from the property object. We need
+                            // to remove this flag here so the method is seen as an instance method rather than
+                            // static. Otherwise we'll incorrectly report that "self" is not annotated.
+                            accessType = types_1.FunctionType.cloneWithNewFlags(accessType, accessType.details.flags & ~4 /* StaticMethod */);
+                        }
+                        knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getSymbolTypeKnownStatus(report, symbolInfo, accessType, (0, textRange_1.getEmptyRange)(), '', publicSymbolMap));
+                    });
+                    break;
+                }
+                if (!this._shouldIgnoreType(report, type.details.fullName)) {
+                    // Don't bother type-checking built-in types.
+                    if (!types_1.ClassType.isBuiltIn(type)) {
+                        // Reference the class.
+                        this._getSymbolForClass(report, type, publicSymbolMap);
+                    }
+                }
+                // Analyze type arguments if present to make sure they are known.
+                if (type.typeArguments) {
+                    type.typeArguments.forEach((typeArg, index) => {
+                        if ((0, types_1.isUnknown)(typeArg)) {
+                            this._addSymbolError(symbolInfo, `Type argument ${index + 1} for class "${type.details.name}" has unknown type`, declRange, declFilePath);
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                        }
+                        else if ((0, typeUtils_1.isPartlyUnknown)(typeArg)) {
+                            const diag = new diagnostic_1.DiagnosticAddendum();
+                            diag.addMessage(`Type is ${this._program.printType(typeArg, /* expandTypeAlias */ false)}`);
+                            this._addSymbolError(symbolInfo, `Type argument ${index + 1} for class "${type.details.name}" has partially unknown type` + diag.getString(), declRange, declFilePath);
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 2 /* PartiallyUnknown */);
+                        }
+                    });
+                }
+                break;
+            }
+            case 8 /* Module */: {
+                if (!this._shouldIgnoreType(report, type.moduleName)) {
+                    const moduleSymbol = this._getSymbolForModule(report, type, publicSymbolMap);
+                    if (moduleSymbol.typeKnownStatus !== 0 /* Known */) {
+                        this._addSymbolError(symbolInfo, `Module "${moduleSymbol.fullName}" is partially unknown`, declRange, declFilePath);
+                        knownStatus = this._updateKnownStatusIfWorse(knownStatus, moduleSymbol.typeKnownStatus);
+                    }
+                }
+                break;
+            }
+        }
+        // Downgrade the symbol's type known status info.
+        symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, knownStatus);
+        return knownStatus;
+    }
+    _getFunctionTypeKnownStatus(report, type, publicSymbolMap, symbolInfo, declRange, declFilePath, diag) {
+        let knownStatus = 0 /* Known */;
+        // If the file path wasn't provided, try to get it from the type.
+        if (type.details.declaration && !declFilePath) {
+            declFilePath = type.details.declaration.path;
+        }
+        type.details.parameters.forEach((param, index) => {
+            // Skip nameless parameters like "*" and "/".
+            if (param.name) {
+                if (!param.hasDeclaredType) {
+                    // Allow params (like "self" and "cls") to skip declarations because
+                    // we're able to synthesize these.
+                    const isSynthesized = index === 0 &&
+                        (symbolInfo === null || symbolInfo === void 0 ? void 0 : symbolInfo.scopeType) === 2 /* Class */ &&
+                        (types_1.FunctionType.isClassMethod(type) ||
+                            types_1.FunctionType.isInstanceMethod(type) ||
+                            types_1.FunctionType.isConstructorMethod(type));
+                    if (!isSynthesized) {
+                        if (symbolInfo) {
+                            this._addSymbolError(symbolInfo, `Type annotation for parameter "${param.name}" is missing`, declRange || (0, textRange_1.getEmptyRange)(), declFilePath || '');
+                        }
+                        diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(`Type annotation for parameter "${param.name}" is missing`);
+                        knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                    }
+                }
+                else if ((0, types_1.isUnknown)(param.type)) {
+                    if (symbolInfo) {
+                        this._addSymbolError(symbolInfo, `Type of parameter "${param.name}" is unknown`, declRange || (0, textRange_1.getEmptyRange)(), declFilePath || '');
+                        diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(`Type of parameter "${param.name}" is unknown`);
+                    }
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                }
+                else {
+                    const extraInfo = new diagnostic_1.DiagnosticAddendum();
+                    const paramKnownStatus = this._getTypeKnownStatus(report, param.type, publicSymbolMap, extraInfo.createAddendum());
+                    if (paramKnownStatus !== 0 /* Known */) {
+                        extraInfo.addMessage(`Parameter type is "${this._program.printType(param.type, /* expandTypeAlias */ false)}"`);
+                        if (symbolInfo) {
+                            this._addSymbolError(symbolInfo, `Type of parameter "${param.name}" is partially unknown` + extraInfo.getString(), declRange || (0, textRange_1.getEmptyRange)(), declFilePath || '');
+                        }
+                        if (diag) {
+                            const subDiag = diag.createAddendum();
+                            subDiag.addMessage(`Type of parameter "${param.name}" is partially unknown`);
+                            subDiag.addAddendum(extraInfo);
+                        }
+                        knownStatus = this._updateKnownStatusIfWorse(knownStatus, paramKnownStatus);
+                    }
+                }
+            }
+        });
+        if (type.details.declaredReturnType) {
+            if ((0, types_1.isUnknown)(type.details.declaredReturnType)) {
+                if (symbolInfo) {
+                    this._addSymbolError(symbolInfo, `Return type is unknown`, declRange || (0, textRange_1.getEmptyRange)(), declFilePath || '');
+                }
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+            }
+            else {
+                const extraInfo = new diagnostic_1.DiagnosticAddendum();
+                const returnTypeKnownStatus = this._getTypeKnownStatus(report, type.details.declaredReturnType, publicSymbolMap, extraInfo.createAddendum());
+                if (returnTypeKnownStatus !== 0 /* Known */) {
+                    extraInfo.addMessage(`Return type is "${this._program.printType(type.details.declaredReturnType, 
+                    /* expandTypeAlias */ false)}"`);
+                    if (symbolInfo) {
+                        this._addSymbolError(symbolInfo, `Return type is partially unknown` + extraInfo.getString(), declRange || (0, textRange_1.getEmptyRange)(), declFilePath || '');
+                    }
+                    if (diag) {
+                        const subDiag = diag.createAddendum();
+                        subDiag.addMessage(`Return type is partially unknown`);
+                        subDiag.addAddendum(extraInfo);
+                    }
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, returnTypeKnownStatus);
+                }
+            }
+        }
+        else {
+            // Init methods have an implied return type.
+            if (type.details.name !== '__init__') {
+                if (symbolInfo) {
+                    this._addSymbolError(symbolInfo, `Return type annotation is missing`, declRange || (0, textRange_1.getEmptyRange)(), declFilePath || '');
+                }
+                diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(`Return type annotation is missing`);
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+            }
+        }
+        if (!type.details.docString) {
+            // Don't require docstrings for dunder methods.
+            if ((symbolInfo === null || symbolInfo === void 0 ? void 0 : symbolInfo.isExported) && !(0, symbolNameUtils_1.isDunderName)(symbolInfo.name)) {
+                if (symbolInfo) {
+                    this._addSymbolWarning(symbolInfo, `No docstring found for function "${symbolInfo.fullName}"`, declRange || (0, textRange_1.getEmptyRange)(), declFilePath || '');
+                }
+                report.missingFunctionDocStringCount++;
+            }
+        }
+        if (type.details.parameters.find((param) => param.defaultType && (0, typeUtils_1.isEllipsisType)(param.defaultType))) {
+            if (symbolInfo) {
+                this._addSymbolWarning(symbolInfo, `One or more default values in function "${symbolInfo.fullName}" is specified as "..."`, declRange || (0, textRange_1.getEmptyRange)(), declFilePath || '');
+            }
+            report.missingDefaultParamCount++;
+        }
+        if (symbolInfo) {
+            symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, knownStatus);
+        }
+        return knownStatus;
+    }
+    _getSymbolForClass(report, type, publicSymbolMap) {
+        // See if this type is already analyzed.
+        const cachedType = report.symbols.get(type.details.fullName);
+        if (cachedType) {
+            cachedType.referenceCount++;
+            return cachedType;
+        }
+        const symbolInfo = {
+            category: packageTypeReport_1.SymbolCategory.Class,
+            name: type.details.name,
+            fullName: type.details.fullName,
+            filePath: type.details.filePath,
+            isExported: publicSymbolMap.has(type.details.fullName),
+            typeKnownStatus: 0 /* Known */,
+            referenceCount: 1,
+            diagnostics: [],
+            scopeType: 2 /* Class */,
+        };
+        this._addSymbol(report, symbolInfo);
+        // Determine whether the class has a proper doc string.
+        if (symbolInfo.isExported && !type.details.docString) {
+            this._addSymbolWarning(symbolInfo, `No docstring found for class "${type.details.fullName}"`, (0, textRange_1.getEmptyRange)(), '');
+            report.missingClassDocStringCount++;
+        }
+        const symbolTableTypeKnownStatus = this._getTypeKnownStatusForSymbolTable(report, type.details.fullName, type.details.fields, 2 /* Class */, publicSymbolMap, (name, symbol) => {
+            // If the symbol within this class is lacking a type declaration,
+            // see if we can find a same-named symbol in a parent class with
+            // a type declaration.
+            if (!symbol.hasTypedDeclarations()) {
+                for (const mroClass of type.details.mro.slice(1)) {
+                    if ((0, types_1.isClass)(mroClass)) {
+                        const overrideSymbol = mroClass.details.fields.get(name);
+                        if (overrideSymbol && overrideSymbol.hasTypedDeclarations()) {
+                            return overrideSymbol;
+                        }
+                    }
+                }
+            }
+            return symbol;
+        });
+        symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, symbolTableTypeKnownStatus);
+        // Add information for the metaclass.
+        if (type.details.effectiveMetaclass) {
+            if (!(0, types_1.isInstantiableClass)(type.details.effectiveMetaclass)) {
+                this._addSymbolError(symbolInfo, `Type of metaclass unknown`, (0, textRange_1.getEmptyRange)(), '');
+                symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, 2 /* PartiallyUnknown */);
+            }
+            else {
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                const metaclassKnownStatus = this._getTypeKnownStatus(report, type.details.effectiveMetaclass, publicSymbolMap, diag);
+                if (metaclassKnownStatus !== 0 /* Known */) {
+                    this._addSymbolError(symbolInfo, `Type of metaclass "${type.details.effectiveMetaclass}" is partially unknown` +
+                        diag.getString(), (0, textRange_1.getEmptyRange)(), '');
+                    symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, metaclassKnownStatus);
+                }
+            }
+        }
+        // Add information for base classes.
+        type.details.baseClasses.forEach((baseClass) => {
+            if (!(0, types_1.isInstantiableClass)(baseClass)) {
+                this._addSymbolError(symbolInfo, `Type of base class unknown`, (0, textRange_1.getEmptyRange)(), '');
+                symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, 2 /* PartiallyUnknown */);
+            }
+            else {
+                // Handle "tuple" specially. Even though it's a generic class, it
+                // doesn't require a type argument.
+                if (types_1.ClassType.isBuiltIn(baseClass, 'tuple')) {
+                    return;
+                }
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                const baseClassTypeStatus = this._getTypeKnownStatus(report, baseClass, publicSymbolMap, diag);
+                if (baseClassTypeStatus !== 0 /* Known */) {
+                    this._addSymbolError(symbolInfo, `Type of base class "${baseClass.details.fullName}" is partially unknown` + diag.getString(), (0, textRange_1.getEmptyRange)(), '');
+                    symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, baseClassTypeStatus);
+                }
+            }
+        });
+        return symbolInfo;
+    }
+    _getSymbolForModule(report, type, publicSymbolMap) {
+        // See if this type is already analyzed.
+        const cachedType = report.symbols.get(type.moduleName);
+        if (cachedType) {
+            cachedType.referenceCount++;
+            return cachedType;
+        }
+        const symbolInfo = {
+            category: packageTypeReport_1.SymbolCategory.Module,
+            name: type.moduleName,
+            fullName: type.moduleName,
+            filePath: type.filePath,
+            isExported: publicSymbolMap.has(type.moduleName),
+            typeKnownStatus: 0 /* Known */,
+            referenceCount: 1,
+            diagnostics: [],
+            scopeType: 3 /* Module */,
+        };
+        this._addSymbol(report, symbolInfo);
+        const symbolTableTypeKnownStatus = this._getTypeKnownStatusForSymbolTable(report, type.moduleName, type.fields, 3 /* Module */, publicSymbolMap);
+        symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, symbolTableTypeKnownStatus);
+        return symbolInfo;
+    }
+    _getTypeKnownStatus(report, type, publicSymbolMap, diag) {
+        let knownStatus = 0 /* Known */;
+        if (type.typeAliasInfo && type.typeAliasInfo.typeArguments) {
+            type.typeAliasInfo.typeArguments.forEach((typeArg, index) => {
+                if ((0, types_1.isUnknown)(typeArg)) {
+                    diag.addMessage(`Type argument ${index + 1} for type alias "${type.typeAliasInfo.name}" has unknown type`);
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                }
+                else if ((0, typeUtils_1.isPartlyUnknown)(typeArg)) {
+                    diag.addMessage(`Type argument ${index + 1} for type alias "${type.typeAliasInfo.name}" has partially unknown type`);
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, 2 /* PartiallyUnknown */);
+                }
+            });
+        }
+        if (types_1.TypeBase.isAmbiguous(type)) {
+            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 1 /* Ambiguous */);
+        }
+        switch (type.category) {
+            case 0 /* Unbound */:
+            case 2 /* Any */:
+            case 3 /* None */:
+            case 4 /* Never */:
+            case 10 /* TypeVar */:
+                break;
+            case 1 /* Unknown */: {
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                break;
+            }
+            case 9 /* Union */: {
+                (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getTypeKnownStatus(report, subtype, publicSymbolMap, diag.createAddendum()));
+                });
+                break;
+            }
+            case 6 /* OverloadedFunction */: {
+                for (const overload of type.overloads) {
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getTypeKnownStatus(report, overload, publicSymbolMap, diag.createAddendum()));
+                }
+                break;
+            }
+            case 5 /* Function */: {
+                if (!this._shouldIgnoreType(report, type.details.fullName)) {
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getFunctionTypeKnownStatus(report, type, publicSymbolMap, 
+                    /* symbolInfo */ undefined, 
+                    /* declRange */ undefined, 
+                    /* declFilePath */ undefined, diag));
+                }
+                break;
+            }
+            case 7 /* Class */: {
+                if (!this._shouldIgnoreType(report, type.details.fullName)) {
+                    // Don't bother type-checking built-in types.
+                    if (!types_1.ClassType.isBuiltIn(type)) {
+                        // Reference the class.
+                        this._getSymbolForClass(report, type, publicSymbolMap);
+                    }
+                }
+                // Analyze type arguments if present to make sure they are known.
+                if (type.typeArguments) {
+                    type.typeArguments.forEach((typeArg, index) => {
+                        if ((0, types_1.isUnknown)(typeArg)) {
+                            diag.addMessage(`Type argument ${index + 1} for class "${type.details.name}" has unknown type`);
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                        }
+                        else if ((0, typeUtils_1.isPartlyUnknown)(typeArg)) {
+                            diag.addMessage(`Type argument ${index + 1} for class "${type.details.name}" has partially unknown type`);
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 2 /* PartiallyUnknown */);
+                        }
+                    });
+                }
+                break;
+            }
+            case 8 /* Module */: {
+                if (!this._shouldIgnoreType(report, type.moduleName)) {
+                    const moduleSymbol = this._getSymbolForModule(report, type, publicSymbolMap);
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, moduleSymbol.typeKnownStatus);
+                }
+                break;
+            }
+        }
+        return knownStatus;
+    }
+    _getSymbolCategory(symbol, type) {
+        if (type.typeAliasInfo) {
+            return packageTypeReport_1.SymbolCategory.TypeAlias;
+        }
+        switch (type.category) {
+            case 5 /* Function */:
+            case 6 /* OverloadedFunction */: {
+                const funcDecl = symbol
+                    .getDeclarations()
+                    .find((decl) => decl.type === 3 /* Function */);
+                if (funcDecl && funcDecl.isMethod) {
+                    return packageTypeReport_1.SymbolCategory.Method;
+                }
+                return packageTypeReport_1.SymbolCategory.Function;
+            }
+            case 7 /* Class */: {
+                if (types_1.TypeBase.isInstantiable(type)) {
+                    return packageTypeReport_1.SymbolCategory.Class;
+                }
+                const varDecl = symbol
+                    .getDeclarations()
+                    .find((decl) => decl.type === 1 /* Variable */);
+                if (varDecl && (varDecl.isConstant || varDecl.isFinal)) {
+                    return packageTypeReport_1.SymbolCategory.Constant;
+                }
+                return packageTypeReport_1.SymbolCategory.Variable;
+            }
+            case 8 /* Module */: {
+                return packageTypeReport_1.SymbolCategory.Module;
+            }
+            case 10 /* TypeVar */: {
+                return packageTypeReport_1.SymbolCategory.TypeVar;
+            }
+            default: {
+                const varDecl = symbol
+                    .getDeclarations()
+                    .find((decl) => decl.type === 1 /* Variable */);
+                if (varDecl) {
+                    if (varDecl.isConstant || varDecl.isFinal) {
+                        return packageTypeReport_1.SymbolCategory.Constant;
+                    }
+                    else {
+                        return packageTypeReport_1.SymbolCategory.Variable;
+                    }
+                }
+                return packageTypeReport_1.SymbolCategory.Indeterminate;
+            }
+        }
+    }
+    _getDirectoryForModule(moduleName) {
+        var _a;
+        const importResult = this._importResolver.resolveImport('', this._execEnv, (0, importResolver_1.createImportedModuleDescriptor)(moduleName));
+        if (importResult.isImportFound) {
+            const resolvedPath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
+            if (resolvedPath) {
+                return (0, pathUtils_1.getDirectoryPath)(resolvedPath);
+            }
+            // If it's a namespace package with no __init__.py(i), use the package
+            // directory instead.
+            return (_a = importResult.packageDirectory) !== null && _a !== void 0 ? _a : '';
+        }
+        return undefined;
+    }
+    _isSymbolTypeImplied(scopeType, name) {
+        if (scopeType === 2 /* Class */) {
+            const knownClassSymbols = [
+                '__class__',
+                '__dict__',
+                '__doc__',
+                '__module__',
+                '__qualname__',
+                '__slots__',
+                '__all__',
+                '__weakref__',
+            ];
+            return knownClassSymbols.some((sym) => sym === name);
+        }
+        else if (scopeType === 3 /* Module */) {
+            const knownModuleSymbols = [
+                '__all__',
+                '__author__',
+                '__copyright__',
+                '__email__',
+                '__license__',
+                '__title__',
+                '__uri__',
+                '__version__',
+            ];
+            return knownModuleSymbols.some((sym) => sym === name);
+        }
+        return false;
+    }
+    _addSymbol(report, symbolInfo) {
+        (0, debug_1.assert)(!report.symbols.has(symbolInfo.fullName));
+        report.symbols.set(symbolInfo.fullName, symbolInfo);
+    }
+    _addSymbolError(symbolInfo, message, declRange, declFilePath) {
+        symbolInfo.diagnostics.push({
+            diagnostic: new diagnostic_1.Diagnostic(0 /* Error */, message, declRange),
+            filePath: declFilePath,
+        });
+    }
+    _addSymbolWarning(symbolInfo, message, declRange, declFilePath) {
+        symbolInfo.diagnostics.push({
+            diagnostic: new diagnostic_1.Diagnostic(1 /* Warning */, message, declRange),
+            filePath: declFilePath,
+        });
+    }
+    _updateKnownStatusIfWorse(currentStatus, newStatus) {
+        // Is the current status worse than the current status.
+        return newStatus > currentStatus ? newStatus : currentStatus;
+    }
+}
+exports.PackageTypeVerifier = PackageTypeVerifier;
+//# sourceMappingURL=packageTypeVerifier.js.map