@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/analyzer/packageTypeVerifier.ts

@@ -0,0 +1,1466 @@
+/*
+ * 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.
+ */
+
+import { ConfigOptions, ExecutionEnvironment } from '../common/configOptions';
+import { assert } from '../common/debug';
+import { Diagnostic, DiagnosticAddendum, DiagnosticCategory } from '../common/diagnostic';
+import { FileSystem } from '../common/fileSystem';
+import { FullAccessHost } from '../common/fullAccessHost';
+import { combinePaths, getDirectoryPath, getFileExtension, stripFileExtension, tryStat } from '../common/pathUtils';
+import { getEmptyRange, Range } from '../common/textRange';
+import { DeclarationType, FunctionDeclaration, VariableDeclaration } from './declaration';
+import { createImportedModuleDescriptor, ImportResolver } from './importResolver';
+import {
+    AlternateSymbolNameMap,
+    getEmptyReport,
+    ModuleInfo,
+    PackageTypeReport,
+    SymbolCategory,
+    SymbolInfo,
+    TypeKnownStatus,
+} from './packageTypeReport';
+import { Program } from './program';
+import { getPyTypedInfo, PyTypedInfo } from './pyTypedUtils';
+import { ScopeType } from './scope';
+import { getScopeForNode } from './scopeUtils';
+import { Symbol, SymbolTable } from './symbol';
+import { isDunderName, isPrivateOrProtectedName } from './symbolNameUtils';
+import {
+    ClassType,
+    FunctionType,
+    FunctionTypeFlags,
+    isClass,
+    isFunction,
+    isInstantiableClass,
+    isModule,
+    isTypeSame,
+    isUnknown,
+    ModuleType,
+    Type,
+    TypeBase,
+    TypeCategory,
+} from './types';
+import {
+    doForEachSubtype,
+    getFullNameOfType,
+    isDescriptorInstance,
+    isEllipsisType,
+    isPartlyUnknown,
+} from './typeUtils';
+
+type PublicSymbolMap = Map<string, string>;
+
+export class PackageTypeVerifier {
+    private _configOptions: ConfigOptions;
+    private _execEnv: ExecutionEnvironment;
+    private _importResolver: ImportResolver;
+    private _program: Program;
+
+    constructor(private _fileSystem: FileSystem, private _packageName: string, private _ignoreExternal = false) {
+        this._configOptions = new ConfigOptions('');
+
+        if (_ignoreExternal) {
+            this._configOptions.evaluateUnknownImportsAsAny = true;
+        }
+
+        this._execEnv = this._configOptions.findExecEnvironment('.');
+        this._importResolver = new ImportResolver(
+            this._fileSystem,
+            this._configOptions,
+            new FullAccessHost(this._fileSystem)
+        );
+        this._program = new Program(this._importResolver, this._configOptions);
+    }
+
+    verify(): PackageTypeReport {
+        const trimmedModuleName = this._packageName.trim();
+        const moduleNameParts = trimmedModuleName.split('.');
+
+        const report = getEmptyReport(
+            moduleNameParts[0],
+            this._getDirectoryForModule(moduleNameParts[0]) ?? '',
+            trimmedModuleName,
+            this._getDirectoryForModule(trimmedModuleName) ?? '',
+            this._ignoreExternal
+        );
+        const commonDiagnostics = report.generalDiagnostics;
+
+        try {
+            if (!trimmedModuleName) {
+                commonDiagnostics.push(
+                    new Diagnostic(
+                        DiagnosticCategory.Error,
+                        `Module name "${trimmedModuleName}" is invalid`,
+                        getEmptyRange()
+                    )
+                );
+            } else if (!report.moduleRootDirectory) {
+                commonDiagnostics.push(
+                    new Diagnostic(
+                        DiagnosticCategory.Error,
+                        `Module "${trimmedModuleName}" cannot be resolved`,
+                        getEmptyRange()
+                    )
+                );
+            } else {
+                let pyTypedInfo: PyTypedInfo | undefined;
+                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(DiagnosticCategory.Error, 'No py.typed file found', 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(
+                                DiagnosticCategory.Error,
+                                `Module "${trimmedModuleName}" cannot be resolved`,
+                                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<string, string>();
+                    publicModules.forEach((moduleName) => {
+                        this._getPublicSymbolsForModule(moduleName, publicSymbolMap, report.alternateSymbolNames);
+                    });
+
+                    publicModules.forEach((moduleName) => {
+                        this._verifyTypesOfModule(moduleName, publicSymbolMap, report);
+                    });
+                }
+            }
+        } catch (e: any) {
+            const message: string =
+                (e.stack ? e.stack.toString() : undefined) ||
+                (typeof e.message === 'string' ? e.message : undefined) ||
+                JSON.stringify(e);
+            commonDiagnostics.push(
+                new Diagnostic(
+                    DiagnosticCategory.Error,
+                    `An internal error occurred while verifying types: "${message}"`,
+                    getEmptyRange()
+                )
+            );
+        }
+
+        return report;
+    }
+
+    static getSymbolCategoryString(symbolType: SymbolCategory): string {
+        switch (symbolType) {
+            case SymbolCategory.Class:
+                return 'class';
+
+            case SymbolCategory.Function:
+                return 'function';
+
+            case SymbolCategory.Method:
+                return 'method';
+
+            case SymbolCategory.Constant:
+                return 'constant';
+
+            case SymbolCategory.Variable:
+                return 'variable';
+
+            case SymbolCategory.Module:
+                return 'module';
+
+            case SymbolCategory.TypeAlias:
+                return 'type alias';
+
+            case SymbolCategory.TypeVar:
+                return 'type variable';
+
+            case SymbolCategory.Indeterminate:
+                return 'symbol';
+        }
+    }
+
+    private _getDeepestPyTypedInfo(rootDirectory: string, packageNameParts: string[]) {
+        let subNameParts = [...packageNameParts];
+
+        // Find the deepest py.typed file that corresponds to the requested submodule.
+        while (subNameParts.length >= 1) {
+            const packageSubdir = combinePaths(rootDirectory, ...subNameParts.slice(1));
+            const pyTypedInfo = getPyTypedInfo(this._fileSystem, packageSubdir);
+            if (pyTypedInfo) {
+                return pyTypedInfo;
+            }
+
+            subNameParts = subNameParts.slice(0, subNameParts.length - 1);
+        }
+
+        return undefined;
+    }
+
+    private _resolveImport(moduleName: string) {
+        return this._importResolver.resolveImport('', this._execEnv, createImportedModuleDescriptor(moduleName));
+    }
+
+    private _getPublicSymbolsForModule(
+        moduleName: string,
+        symbolMap: PublicSymbolMap,
+        alternateSymbolNames: AlternateSymbolNameMap
+    ) {
+        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: ModuleInfo = {
+                    name: moduleName,
+                    path: modulePath,
+                    isExported: true,
+                };
+
+                const parseTree = sourceFile.getParseResults()!.parseTree;
+                const moduleScope = getScopeForNode(parseTree)!;
+
+                this._getPublicSymbolsInSymbolTable(
+                    symbolMap,
+                    alternateSymbolNames,
+                    module,
+                    module.name,
+                    moduleScope.symbolTable,
+                    ScopeType.Module
+                );
+            }
+        }
+    }
+
+    private _getPublicSymbolsInSymbolTable(
+        symbolMap: PublicSymbolMap,
+        alternateSymbolNames: AlternateSymbolNameMap,
+        module: ModuleInfo,
+        scopeName: string,
+        symbolTable: SymbolTable,
+        scopeType: ScopeType
+    ) {
+        symbolTable.forEach((symbol, name) => {
+            if (
+                !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 === DeclarationType.Class);
+                        if (classDecl) {
+                            if (isInstantiableClass(symbolType)) {
+                                this._getPublicSymbolsInSymbolTable(
+                                    symbolMap,
+                                    alternateSymbolNames,
+                                    module,
+                                    fullName,
+                                    symbolType.details.fields,
+                                    ScopeType.Class
+                                );
+                            }
+                        }
+                    }
+
+                    // Is this the re-export of an import? If so, record the alternate name.
+                    const importDecl = symbol.getDeclarations().find((decl) => decl.type === DeclarationType.Alias);
+                    if (importDecl && importDecl.type === DeclarationType.Alias) {
+                        const typeName = getFullNameOfType(this._program.getTypeOfSymbol(symbol));
+                        if (typeName) {
+                            this._addAlternateSymbolName(alternateSymbolNames, typeName, fullName);
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    private _addAlternateSymbolName(map: AlternateSymbolNameMap, name: string, altName: string) {
+        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);
+            }
+        }
+    }
+
+    private _verifyTypesOfModule(moduleName: string, publicSymbolMap: PublicSymbolMap, report: PackageTypeReport) {
+        const importResult = this._resolveImport(moduleName);
+        if (!importResult.isImportFound) {
+            report.generalDiagnostics.push(
+                new Diagnostic(DiagnosticCategory.Error, `Could not resolve module "${moduleName}"`, getEmptyRange())
+            );
+        } else if (importResult.isStubPackage) {
+            report.generalDiagnostics.push(
+                new Diagnostic(
+                    DiagnosticCategory.Error,
+                    `No inlined types found for module "${moduleName}" because stub package was present`,
+                    getEmptyRange()
+                )
+            );
+        } else {
+            const modulePath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
+
+            const module: ModuleInfo = {
+                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 = getScopeForNode(parseTree)!;
+
+                this._getTypeKnownStatusForSymbolTable(
+                    report,
+                    module.name,
+                    moduleScope.symbolTable,
+                    ScopeType.Module,
+                    publicSymbolMap
+                );
+            } else {
+                report.generalDiagnostics.push(
+                    new Diagnostic(DiagnosticCategory.Error, `Could not bind file "${modulePath}"`, getEmptyRange())
+                );
+            }
+        }
+    }
+
+    // Scans the directory structure for a list of public modules
+    // within the package.
+    private _getListOfPublicModules(moduleRootPath: string, moduleName: string): string[] {
+        const publicModules: string[] = [];
+        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: string[] = [];
+        const moduleMap = new Map<string, string>();
+
+        publicModules.forEach((module) => {
+            if (!moduleMap.has(module)) {
+                uniqueModules.push(module);
+                moduleMap.set(module, module);
+            }
+        });
+
+        return uniqueModules;
+    }
+
+    private _addPublicModulesRecursive(dirPath: string, modulePath: string, publicModules: string[]) {
+        const dirEntries = this._fileSystem.readdirEntriesSync(dirPath);
+
+        dirEntries.forEach((entry) => {
+            let isFile = entry.isFile();
+            let isDirectory = entry.isDirectory();
+            if (entry.isSymbolicLink()) {
+                const stat = tryStat(this._fileSystem, combinePaths(dirPath, entry.name));
+                if (stat) {
+                    isFile = stat.isFile();
+                    isDirectory = stat.isDirectory();
+                }
+            }
+
+            if (isFile) {
+                const fileExtension = getFileExtension(entry.name);
+
+                if (fileExtension === '.py' || fileExtension === '.pyi') {
+                    const nameWithoutExtension = stripFileExtension(entry.name);
+
+                    if (nameWithoutExtension === '__init__') {
+                        publicModules.push(modulePath);
+                    } else {
+                        if (
+                            !isPrivateOrProtectedName(nameWithoutExtension) &&
+                            this._isLegalModulePartName(nameWithoutExtension)
+                        ) {
+                            publicModules.push(`${modulePath}.${nameWithoutExtension}`);
+                        }
+                    }
+                }
+            } else if (isDirectory) {
+                if (!isPrivateOrProtectedName(entry.name) && this._isLegalModulePartName(entry.name)) {
+                    this._addPublicModulesRecursive(
+                        combinePaths(dirPath, entry.name),
+                        `${modulePath}.${entry.name}`,
+                        publicModules
+                    );
+                }
+            }
+        });
+    }
+
+    private _isLegalModulePartName(name: string): boolean {
+        // 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_]+/);
+    }
+
+    private _shouldIgnoreType(report: PackageTypeReport, fullTypeName: string) {
+        // If we're ignoring unknown types from other packages, see if we should skip.
+        return report.ignoreExternal && !fullTypeName.startsWith(report.packageName);
+    }
+
+    private _getTypeKnownStatusForSymbolTable(
+        report: PackageTypeReport,
+        scopeName: string,
+        symbolTable: SymbolTable,
+        scopeType: ScopeType,
+        publicSymbolMap: PublicSymbolMap,
+        overrideSymbolCallback?: (name: string, symbol: Symbol) => Symbol
+    ): TypeKnownStatus {
+        if (this._shouldIgnoreType(report, scopeName)) {
+            return TypeKnownStatus.Known;
+        }
+
+        let knownStatus = TypeKnownStatus.Known;
+
+        symbolTable.forEach((symbol, name) => {
+            if (
+                !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: Type | undefined;
+                let childSymbolType: Type | undefined;
+
+                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 (TypeBase.isAmbiguous(childSymbolType) || !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 (!isDescriptorInstance(baseSymbolType, /* requireSetter */ true)) {
+                                usesAmbiguousOverride = true;
+                            }
+                        }
+
+                        symbolType = baseSymbolType;
+                    }
+                }
+
+                const typedDecls = symbol.getTypedDeclarations();
+                const primaryDecl = typedDecls.length > 0 ? typedDecls[typedDecls.length - 1] : undefined;
+                let symbolInfo: SymbolInfo;
+
+                if (primaryDecl?.type === DeclarationType.Class && isInstantiableClass(symbolType)) {
+                    symbolInfo = this._getSymbolForClass(report, symbolType, publicSymbolMap);
+                } else if (primaryDecl?.type === DeclarationType.Alias && 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?.range || getEmptyRange();
+                    const declPath = 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?.type === DeclarationType.Variable &&
+                        primaryDecl.isDefinedBySlots
+                    ) {
+                        return;
+                    }
+
+                    symbolInfo = {
+                        category: symbolCategory,
+                        name,
+                        fullName,
+                        filePath: module.path,
+                        isExported,
+                        typeKnownStatus: TypeKnownStatus.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?.range || getEmptyRange();
+                    const declPath = primaryDecl?.path || '';
+
+                    const extraInfo = new 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 (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,
+                        TypeKnownStatus.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.
+    private _getSymbolTypeKnownStatus(
+        report: PackageTypeReport,
+        symbolInfo: SymbolInfo,
+        type: Type,
+        declRange: Range,
+        declFilePath: string,
+        publicSymbolMap: PublicSymbolMap
+    ): TypeKnownStatus {
+        let knownStatus = TypeKnownStatus.Known;
+
+        if (type.typeAliasInfo && type.typeAliasInfo.typeArguments) {
+            type.typeAliasInfo.typeArguments.forEach((typeArg, index) => {
+                if (isUnknown(typeArg)) {
+                    this._addSymbolError(
+                        symbolInfo,
+                        `Type argument ${index + 1} for type alias "${type.typeAliasInfo!.name}" has unknown type`,
+                        declRange,
+                        declFilePath
+                    );
+                    knownStatus = TypeKnownStatus.Unknown;
+                } else if (isPartlyUnknown(typeArg)) {
+                    this._addSymbolError(
+                        symbolInfo,
+                        `Type argument ${index + 1} for type alias "${
+                            type.typeAliasInfo!.name
+                        }" has partially unknown type`,
+                        declRange,
+                        declFilePath
+                    );
+                    knownStatus = TypeKnownStatus.PartiallyUnknown;
+                }
+            });
+        }
+
+        if (TypeBase.isAmbiguous(type) && !isUnknown(type)) {
+            const ambiguousDiag = new 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, TypeKnownStatus.Ambiguous);
+        }
+
+        switch (type.category) {
+            case TypeCategory.Unbound:
+            case TypeCategory.Any:
+            case TypeCategory.None:
+            case TypeCategory.Never:
+            case TypeCategory.TypeVar:
+                break;
+
+            case TypeCategory.Unknown: {
+                this._addSymbolError(
+                    symbolInfo,
+                    `Type unknown for ${PackageTypeVerifier.getSymbolCategoryString(symbolInfo.category)} "${
+                        symbolInfo.fullName
+                    }"`,
+                    declRange,
+                    declFilePath
+                );
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Unknown);
+                break;
+            }
+
+            case TypeCategory.Union: {
+                doForEachSubtype(type, (subtype) => {
+                    knownStatus = this._updateKnownStatusIfWorse(
+                        knownStatus,
+                        this._getSymbolTypeKnownStatus(
+                            report,
+                            symbolInfo,
+                            subtype,
+                            declRange,
+                            declFilePath,
+                            publicSymbolMap
+                        )
+                    );
+                });
+                break;
+            }
+
+            case TypeCategory.OverloadedFunction: {
+                for (const overload of type.overloads) {
+                    knownStatus = this._updateKnownStatusIfWorse(
+                        knownStatus,
+                        this._getSymbolTypeKnownStatus(
+                            report,
+                            symbolInfo,
+                            overload,
+                            declRange,
+                            declFilePath,
+                            publicSymbolMap
+                        )
+                    );
+                }
+                break;
+            }
+
+            case TypeCategory.Function: {
+                if (!this._shouldIgnoreType(report, type.details.fullName)) {
+                    knownStatus = this._updateKnownStatusIfWorse(
+                        knownStatus,
+                        this._getFunctionTypeKnownStatus(
+                            report,
+                            type,
+                            publicSymbolMap,
+                            symbolInfo,
+                            declRange,
+                            declFilePath
+                        )
+                    );
+                }
+
+                break;
+            }
+
+            case TypeCategory.Class: {
+                // Properties require special handling.
+                if (TypeBase.isInstance(type) && 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 (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 = FunctionType.cloneWithNewFlags(
+                                accessType,
+                                accessType.details.flags & ~FunctionTypeFlags.StaticMethod
+                            );
+                        }
+
+                        knownStatus = this._updateKnownStatusIfWorse(
+                            knownStatus,
+                            this._getSymbolTypeKnownStatus(
+                                report,
+                                symbolInfo,
+                                accessType,
+                                getEmptyRange(),
+                                '',
+                                publicSymbolMap
+                            )
+                        );
+                    });
+
+                    break;
+                }
+
+                if (!this._shouldIgnoreType(report, type.details.fullName)) {
+                    // Don't bother type-checking built-in types.
+                    if (!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 (isUnknown(typeArg)) {
+                            this._addSymbolError(
+                                symbolInfo,
+                                `Type argument ${index + 1} for class "${type.details.name}" has unknown type`,
+                                declRange,
+                                declFilePath
+                            );
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Unknown);
+                        } else if (isPartlyUnknown(typeArg)) {
+                            const diag = new 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, TypeKnownStatus.PartiallyUnknown);
+                        }
+                    });
+                }
+
+                break;
+            }
+
+            case TypeCategory.Module: {
+                if (!this._shouldIgnoreType(report, type.moduleName)) {
+                    const moduleSymbol = this._getSymbolForModule(report, type, publicSymbolMap);
+                    if (moduleSymbol.typeKnownStatus !== TypeKnownStatus.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;
+    }
+
+    private _getFunctionTypeKnownStatus(
+        report: PackageTypeReport,
+        type: FunctionType,
+        publicSymbolMap: PublicSymbolMap,
+        symbolInfo?: SymbolInfo,
+        declRange?: Range,
+        declFilePath?: string,
+        diag?: DiagnosticAddendum
+    ): TypeKnownStatus {
+        let knownStatus = TypeKnownStatus.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?.scopeType === ScopeType.Class &&
+                        (FunctionType.isClassMethod(type) ||
+                            FunctionType.isInstanceMethod(type) ||
+                            FunctionType.isConstructorMethod(type));
+
+                    if (!isSynthesized) {
+                        if (symbolInfo) {
+                            this._addSymbolError(
+                                symbolInfo,
+                                `Type annotation for parameter "${param.name}" is missing`,
+                                declRange || getEmptyRange(),
+                                declFilePath || ''
+                            );
+                        }
+                        diag?.createAddendum().addMessage(`Type annotation for parameter "${param.name}" is missing`);
+                        knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Unknown);
+                    }
+                } else if (isUnknown(param.type)) {
+                    if (symbolInfo) {
+                        this._addSymbolError(
+                            symbolInfo,
+                            `Type of parameter "${param.name}" is unknown`,
+                            declRange || getEmptyRange(),
+                            declFilePath || ''
+                        );
+                        diag?.createAddendum().addMessage(`Type of parameter "${param.name}" is unknown`);
+                    }
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Unknown);
+                } else {
+                    const extraInfo = new DiagnosticAddendum();
+                    const paramKnownStatus = this._getTypeKnownStatus(
+                        report,
+                        param.type,
+                        publicSymbolMap,
+                        extraInfo.createAddendum()
+                    );
+
+                    if (paramKnownStatus !== TypeKnownStatus.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 || 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 (isUnknown(type.details.declaredReturnType)) {
+                if (symbolInfo) {
+                    this._addSymbolError(
+                        symbolInfo,
+                        `Return type is unknown`,
+                        declRange || getEmptyRange(),
+                        declFilePath || ''
+                    );
+                }
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Unknown);
+            } else {
+                const extraInfo = new DiagnosticAddendum();
+                const returnTypeKnownStatus = this._getTypeKnownStatus(
+                    report,
+                    type.details.declaredReturnType,
+                    publicSymbolMap,
+                    extraInfo.createAddendum()
+                );
+
+                if (returnTypeKnownStatus !== TypeKnownStatus.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 || 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 || getEmptyRange(),
+                        declFilePath || ''
+                    );
+                }
+                diag?.createAddendum().addMessage(`Return type annotation is missing`);
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Unknown);
+            }
+        }
+
+        if (!type.details.docString) {
+            // Don't require docstrings for dunder methods.
+            if (symbolInfo?.isExported && !isDunderName(symbolInfo.name)) {
+                if (symbolInfo) {
+                    this._addSymbolWarning(
+                        symbolInfo,
+                        `No docstring found for function "${symbolInfo.fullName}"`,
+                        declRange || getEmptyRange(),
+                        declFilePath || ''
+                    );
+                }
+
+                report.missingFunctionDocStringCount++;
+            }
+        }
+
+        if (type.details.parameters.find((param) => param.defaultType && isEllipsisType(param.defaultType))) {
+            if (symbolInfo) {
+                this._addSymbolWarning(
+                    symbolInfo,
+                    `One or more default values in function "${symbolInfo.fullName}" is specified as "..."`,
+                    declRange || getEmptyRange(),
+                    declFilePath || ''
+                );
+            }
+
+            report.missingDefaultParamCount++;
+        }
+
+        if (symbolInfo) {
+            symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, knownStatus);
+        }
+
+        return knownStatus;
+    }
+
+    private _getSymbolForClass(
+        report: PackageTypeReport,
+        type: ClassType,
+        publicSymbolMap: PublicSymbolMap
+    ): SymbolInfo {
+        // See if this type is already analyzed.
+        const cachedType = report.symbols.get(type.details.fullName);
+        if (cachedType) {
+            cachedType.referenceCount++;
+            return cachedType;
+        }
+
+        const symbolInfo: SymbolInfo = {
+            category: SymbolCategory.Class,
+            name: type.details.name,
+            fullName: type.details.fullName,
+            filePath: type.details.filePath,
+            isExported: publicSymbolMap.has(type.details.fullName),
+            typeKnownStatus: TypeKnownStatus.Known,
+            referenceCount: 1,
+            diagnostics: [],
+            scopeType: ScopeType.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}"`,
+                getEmptyRange(),
+                ''
+            );
+
+            report.missingClassDocStringCount++;
+        }
+
+        const symbolTableTypeKnownStatus = this._getTypeKnownStatusForSymbolTable(
+            report,
+            type.details.fullName,
+            type.details.fields,
+            ScopeType.Class,
+            publicSymbolMap,
+            (name: string, symbol: 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 (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 (!isInstantiableClass(type.details.effectiveMetaclass)) {
+                this._addSymbolError(symbolInfo, `Type of metaclass unknown`, getEmptyRange(), '');
+                symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(
+                    symbolInfo.typeKnownStatus,
+                    TypeKnownStatus.PartiallyUnknown
+                );
+            } else {
+                const diag = new DiagnosticAddendum();
+                const metaclassKnownStatus = this._getTypeKnownStatus(
+                    report,
+                    type.details.effectiveMetaclass,
+                    publicSymbolMap,
+                    diag
+                );
+
+                if (metaclassKnownStatus !== TypeKnownStatus.Known) {
+                    this._addSymbolError(
+                        symbolInfo,
+                        `Type of metaclass "${type.details.effectiveMetaclass}" is partially unknown` +
+                            diag.getString(),
+                        getEmptyRange(),
+                        ''
+                    );
+                    symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(
+                        symbolInfo.typeKnownStatus,
+                        metaclassKnownStatus
+                    );
+                }
+            }
+        }
+
+        // Add information for base classes.
+        type.details.baseClasses.forEach((baseClass) => {
+            if (!isInstantiableClass(baseClass)) {
+                this._addSymbolError(symbolInfo, `Type of base class unknown`, getEmptyRange(), '');
+                symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(
+                    symbolInfo.typeKnownStatus,
+                    TypeKnownStatus.PartiallyUnknown
+                );
+            } else {
+                // Handle "tuple" specially. Even though it's a generic class, it
+                // doesn't require a type argument.
+                if (ClassType.isBuiltIn(baseClass, 'tuple')) {
+                    return;
+                }
+
+                const diag = new DiagnosticAddendum();
+                const baseClassTypeStatus = this._getTypeKnownStatus(report, baseClass, publicSymbolMap, diag);
+
+                if (baseClassTypeStatus !== TypeKnownStatus.Known) {
+                    this._addSymbolError(
+                        symbolInfo,
+                        `Type of base class "${baseClass.details.fullName}" is partially unknown` + diag.getString(),
+                        getEmptyRange(),
+                        ''
+                    );
+
+                    symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(
+                        symbolInfo.typeKnownStatus,
+                        baseClassTypeStatus
+                    );
+                }
+            }
+        });
+
+        return symbolInfo;
+    }
+
+    private _getSymbolForModule(
+        report: PackageTypeReport,
+        type: ModuleType,
+        publicSymbolMap: PublicSymbolMap
+    ): SymbolInfo {
+        // See if this type is already analyzed.
+        const cachedType = report.symbols.get(type.moduleName);
+        if (cachedType) {
+            cachedType.referenceCount++;
+            return cachedType;
+        }
+
+        const symbolInfo: SymbolInfo = {
+            category: SymbolCategory.Module,
+            name: type.moduleName,
+            fullName: type.moduleName,
+            filePath: type.filePath,
+            isExported: publicSymbolMap.has(type.moduleName),
+            typeKnownStatus: TypeKnownStatus.Known,
+            referenceCount: 1,
+            diagnostics: [],
+            scopeType: ScopeType.Module,
+        };
+
+        this._addSymbol(report, symbolInfo);
+
+        const symbolTableTypeKnownStatus = this._getTypeKnownStatusForSymbolTable(
+            report,
+            type.moduleName,
+            type.fields,
+            ScopeType.Module,
+            publicSymbolMap
+        );
+
+        symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(
+            symbolInfo.typeKnownStatus,
+            symbolTableTypeKnownStatus
+        );
+
+        return symbolInfo;
+    }
+
+    private _getTypeKnownStatus(
+        report: PackageTypeReport,
+        type: Type,
+        publicSymbolMap: PublicSymbolMap,
+        diag: DiagnosticAddendum
+    ): TypeKnownStatus {
+        let knownStatus = TypeKnownStatus.Known;
+
+        if (type.typeAliasInfo && type.typeAliasInfo.typeArguments) {
+            type.typeAliasInfo.typeArguments.forEach((typeArg, index) => {
+                if (isUnknown(typeArg)) {
+                    diag.addMessage(
+                        `Type argument ${index + 1} for type alias "${type.typeAliasInfo!.name}" has unknown type`
+                    );
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Unknown);
+                } else if (isPartlyUnknown(typeArg)) {
+                    diag.addMessage(
+                        `Type argument ${index + 1} for type alias "${
+                            type.typeAliasInfo!.name
+                        }" has partially unknown type`
+                    );
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.PartiallyUnknown);
+                }
+            });
+        }
+
+        if (TypeBase.isAmbiguous(type)) {
+            knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Ambiguous);
+        }
+
+        switch (type.category) {
+            case TypeCategory.Unbound:
+            case TypeCategory.Any:
+            case TypeCategory.None:
+            case TypeCategory.Never:
+            case TypeCategory.TypeVar:
+                break;
+
+            case TypeCategory.Unknown: {
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Unknown);
+                break;
+            }
+
+            case TypeCategory.Union: {
+                doForEachSubtype(type, (subtype) => {
+                    knownStatus = this._updateKnownStatusIfWorse(
+                        knownStatus,
+                        this._getTypeKnownStatus(report, subtype, publicSymbolMap, diag.createAddendum())
+                    );
+                });
+
+                break;
+            }
+
+            case TypeCategory.OverloadedFunction: {
+                for (const overload of type.overloads) {
+                    knownStatus = this._updateKnownStatusIfWorse(
+                        knownStatus,
+                        this._getTypeKnownStatus(report, overload, publicSymbolMap, diag.createAddendum())
+                    );
+                }
+
+                break;
+            }
+
+            case TypeCategory.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 TypeCategory.Class: {
+                if (!this._shouldIgnoreType(report, type.details.fullName)) {
+                    // Don't bother type-checking built-in types.
+                    if (!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 (isUnknown(typeArg)) {
+                            diag.addMessage(
+                                `Type argument ${index + 1} for class "${type.details.name}" has unknown type`
+                            );
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.Unknown);
+                        } else if (isPartlyUnknown(typeArg)) {
+                            diag.addMessage(
+                                `Type argument ${index + 1} for class "${type.details.name}" has partially unknown type`
+                            );
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, TypeKnownStatus.PartiallyUnknown);
+                        }
+                    });
+                }
+
+                break;
+            }
+
+            case TypeCategory.Module: {
+                if (!this._shouldIgnoreType(report, type.moduleName)) {
+                    const moduleSymbol = this._getSymbolForModule(report, type, publicSymbolMap);
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, moduleSymbol.typeKnownStatus);
+                }
+
+                break;
+            }
+        }
+
+        return knownStatus;
+    }
+
+    private _getSymbolCategory(symbol: Symbol, type: Type): SymbolCategory {
+        if (type.typeAliasInfo) {
+            return SymbolCategory.TypeAlias;
+        }
+
+        switch (type.category) {
+            case TypeCategory.Function:
+            case TypeCategory.OverloadedFunction: {
+                const funcDecl = symbol
+                    .getDeclarations()
+                    .find((decl) => decl.type === DeclarationType.Function) as FunctionDeclaration;
+                if (funcDecl && funcDecl.isMethod) {
+                    return SymbolCategory.Method;
+                }
+
+                return SymbolCategory.Function;
+            }
+
+            case TypeCategory.Class: {
+                if (TypeBase.isInstantiable(type)) {
+                    return SymbolCategory.Class;
+                }
+
+                const varDecl = symbol
+                    .getDeclarations()
+                    .find((decl) => decl.type === DeclarationType.Variable) as VariableDeclaration;
+                if (varDecl && (varDecl.isConstant || varDecl.isFinal)) {
+                    return SymbolCategory.Constant;
+                }
+                return SymbolCategory.Variable;
+            }
+
+            case TypeCategory.Module: {
+                return SymbolCategory.Module;
+            }
+
+            case TypeCategory.TypeVar: {
+                return SymbolCategory.TypeVar;
+            }
+
+            default: {
+                const varDecl = symbol
+                    .getDeclarations()
+                    .find((decl) => decl.type === DeclarationType.Variable) as VariableDeclaration;
+                if (varDecl) {
+                    if (varDecl.isConstant || varDecl.isFinal) {
+                        return SymbolCategory.Constant;
+                    } else {
+                        return SymbolCategory.Variable;
+                    }
+                }
+
+                return SymbolCategory.Indeterminate;
+            }
+        }
+    }
+
+    private _getDirectoryForModule(moduleName: string): string | undefined {
+        const importResult = this._importResolver.resolveImport(
+            '',
+            this._execEnv,
+            createImportedModuleDescriptor(moduleName)
+        );
+
+        if (importResult.isImportFound) {
+            const resolvedPath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
+            if (resolvedPath) {
+                return getDirectoryPath(resolvedPath);
+            }
+
+            // If it's a namespace package with no __init__.py(i), use the package
+            // directory instead.
+            return importResult.packageDirectory ?? '';
+        }
+
+        return undefined;
+    }
+
+    private _isSymbolTypeImplied(scopeType: ScopeType, name: string) {
+        if (scopeType === ScopeType.Class) {
+            const knownClassSymbols = [
+                '__class__',
+                '__dict__',
+                '__doc__',
+                '__module__',
+                '__qualname__',
+                '__slots__',
+                '__all__',
+                '__weakref__',
+            ];
+            return knownClassSymbols.some((sym) => sym === name);
+        } else if (scopeType === ScopeType.Module) {
+            const knownModuleSymbols = [
+                '__all__',
+                '__author__',
+                '__copyright__',
+                '__email__',
+                '__license__',
+                '__title__',
+                '__uri__',
+                '__version__',
+            ];
+            return knownModuleSymbols.some((sym) => sym === name);
+        }
+
+        return false;
+    }
+
+    private _addSymbol(report: PackageTypeReport, symbolInfo: SymbolInfo) {
+        assert(!report.symbols.has(symbolInfo.fullName));
+        report.symbols.set(symbolInfo.fullName, symbolInfo);
+    }
+
+    private _addSymbolError(symbolInfo: SymbolInfo, message: string, declRange: Range, declFilePath: string) {
+        symbolInfo.diagnostics.push({
+            diagnostic: new Diagnostic(DiagnosticCategory.Error, message, declRange),
+            filePath: declFilePath,
+        });
+    }
+
+    private _addSymbolWarning(symbolInfo: SymbolInfo, message: string, declRange: Range, declFilePath: string) {
+        symbolInfo.diagnostics.push({
+            diagnostic: new Diagnostic(DiagnosticCategory.Warning, message, declRange),
+            filePath: declFilePath,
+        });
+    }
+
+    private _updateKnownStatusIfWorse(currentStatus: TypeKnownStatus, newStatus: TypeKnownStatus) {
+        // Is the current status worse than the current status.
+        return newStatus > currentStatus ? newStatus : currentStatus;
+    }
+}