@zzzen/pyright-internal 1.1.254

package/dist/analyzer/checker.js

@@ -0,0 +1,3828 @@
+"use strict";
+/*
+ * checker.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * A parse tree walker that performs static type checking for
+ * a source file. Most of its work is performed by the type
+ * evaluator, but this module touches every node in the file
+ * to ensure that all statements and expressions are evaluated
+ * and checked. It also performs some additional checks that
+ * cannot (or should not be) performed lazily.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checker = void 0;
+const debug_1 = require("../common/debug");
+const diagnostic_1 = require("../common/diagnostic");
+const diagnosticRules_1 = require("../common/diagnosticRules");
+const pathUtils_1 = require("../common/pathUtils");
+const pythonVersion_1 = require("../common/pythonVersion");
+const textRange_1 = require("../common/textRange");
+const localize_1 = require("../localization/localize");
+const parseNodes_1 = require("../parser/parseNodes");
+const stringTokenUtils_1 = require("../parser/stringTokenUtils");
+const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const declaration_1 = require("./declaration");
+const declarationUtils_1 = require("./declarationUtils");
+const importResolver_1 = require("./importResolver");
+const importStatementUtils_1 = require("./importStatementUtils");
+const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
+const parseTreeWalker_1 = require("./parseTreeWalker");
+const patternMatching_1 = require("./patternMatching");
+const protocols_1 = require("./protocols");
+const scopeUtils_1 = require("./scopeUtils");
+const sourceMapper_1 = require("./sourceMapper");
+const staticExpressions_1 = require("./staticExpressions");
+const SymbolNameUtils = __importStar(require("./symbolNameUtils"));
+const symbolUtils_1 = require("./symbolUtils");
+const typeEvaluator_1 = require("./typeEvaluator");
+const types_1 = require("./types");
+const typeUtils_1 = require("./typeUtils");
+const typeVarContext_1 = require("./typeVarContext");
+const deprecatedAliases = new Map([
+    ['Tuple', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.tuple', replacementText: 'tuple' }],
+    ['List', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.list', replacementText: 'list' }],
+    ['Dict', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.dict', replacementText: 'dict' }],
+    ['Set', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.set', replacementText: 'set' }],
+    ['FrozenSet', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.frozenset', replacementText: 'frozenset' }],
+    ['Type', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'builtins.type', replacementText: 'type' }],
+    ['Deque', { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'collections.deque', replacementText: 'collections.deque' }],
+    [
+        'DefaultDict',
+        {
+            version: pythonVersion_1.PythonVersion.V3_9,
+            fullName: 'collections.defaultdict',
+            replacementText: 'collections.defaultdict',
+        },
+    ],
+    [
+        'OrderedDict',
+        {
+            version: pythonVersion_1.PythonVersion.V3_9,
+            fullName: 'collections.OrderedDict',
+            replacementText: 'collections.OrderedDict',
+        },
+    ],
+    [
+        'Counter',
+        { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'collections.Counter', replacementText: 'collections.Counter' },
+    ],
+    [
+        'ChainMap',
+        { version: pythonVersion_1.PythonVersion.V3_9, fullName: 'collections.ChainMap', replacementText: 'collections.ChainMap' },
+    ],
+]);
+const deprecatedSpecialForms = new Map([
+    ['Optional', { version: pythonVersion_1.PythonVersion.V3_10, fullName: 'typing.Optional', replacementText: '| None' }],
+    ['Union', { version: pythonVersion_1.PythonVersion.V3_10, fullName: 'typing.Union', replacementText: '|' }],
+]);
+// When enabled, this debug flag causes the code complexity of
+// functions to be emitted.
+const isPrintCodeComplexityEnabled = false;
+class Checker extends parseTreeWalker_1.ParseTreeWalker {
+    constructor(_importResolver, _evaluator, _moduleNode) {
+        super();
+        this._importResolver = _importResolver;
+        this._evaluator = _evaluator;
+        this._moduleNode = _moduleNode;
+        this._isUnboundCheckSuppressed = false;
+        // A list of all nodes that are defined within the module that
+        // have their own scopes.
+        this._scopedNodes = [];
+        this._fileInfo = AnalyzerNodeInfo.getFileInfo(_moduleNode);
+    }
+    check() {
+        this._scopedNodes.push(this._moduleNode);
+        this._walkStatementsAndReportUnreachable(this._moduleNode.statements);
+        // Mark symbols accessed by __all__ as accessed.
+        const dunderAllInfo = AnalyzerNodeInfo.getDunderAllInfo(this._moduleNode);
+        if (dunderAllInfo) {
+            this._evaluator.markNamesAccessed(this._moduleNode, dunderAllInfo.names);
+            this._reportUnusedDunderAllSymbols(dunderAllInfo.stringNodes);
+        }
+        // Perform a one-time validation of symbols in all scopes
+        // defined in this module for things like unaccessed variables.
+        this._validateSymbolTables();
+        this._reportDuplicateImports();
+        MissingModuleSourceReporter.report(this._importResolver, this._evaluator, this._fileInfo, this._moduleNode);
+    }
+    walk(node) {
+        if (!AnalyzerNodeInfo.isCodeUnreachable(node)) {
+            super.walk(node);
+        }
+        else {
+            this._evaluator.suppressDiagnostics(node, () => {
+                super.walk(node);
+            });
+        }
+    }
+    visitSuite(node) {
+        this._walkStatementsAndReportUnreachable(node.statements);
+        return false;
+    }
+    visitStatementList(node) {
+        node.statements.forEach((statement) => {
+            if ((0, parseNodes_1.isExpressionNode)(statement)) {
+                // Evaluate the expression in case it wasn't otherwise evaluated
+                // through lazy analysis. This will mark referenced symbols as
+                // accessed and report any errors associated with it.
+                this._evaluator.getType(statement);
+                this._reportUnusedExpression(statement);
+            }
+        });
+        return true;
+    }
+    visitClass(node) {
+        const classTypeResult = this._evaluator.getTypeOfClass(node);
+        this.walk(node.suite);
+        this.walkMultiple(node.decorators);
+        this.walkMultiple(node.arguments);
+        if (classTypeResult) {
+            // Protocol classes cannot derive from non-protocol classes.
+            if (types_1.ClassType.isProtocolClass(classTypeResult.classType)) {
+                node.arguments.forEach((arg) => {
+                    if (!arg.name) {
+                        const baseClassType = this._evaluator.getType(arg.valueExpression);
+                        if (baseClassType &&
+                            (0, types_1.isInstantiableClass)(baseClassType) &&
+                            !types_1.ClassType.isBuiltIn(baseClassType, 'Protocol') &&
+                            !types_1.ClassType.isBuiltIn(baseClassType, 'Generic')) {
+                            if (!types_1.ClassType.isProtocolClass(baseClassType)) {
+                                this._evaluator.addError(localize_1.Localizer.Diagnostic.protocolBaseClass().format({
+                                    classType: this._evaluator.printType(classTypeResult.classType, 
+                                    /* expandTypeAlias */ false),
+                                    baseType: this._evaluator.printType(baseClassType, /* expandTypeAlias */ false),
+                                }), arg.valueExpression);
+                            }
+                        }
+                    }
+                });
+                // If this is a generic protocol class, verify that its type variables
+                // have the proper variance.
+                this._validateProtocolTypeParamVariance(node, classTypeResult.classType);
+            }
+            // Skip the overrides check for stub files. Many of the built-in
+            // typeshed stub files trigger this diagnostic. Also skip the slots
+            // check because class variables declared in a stub file are
+            // interpreted as instance variables.
+            if (!this._fileInfo.isStubFile) {
+                this._validateBaseClassOverrides(classTypeResult.classType);
+                this._validateSlotsClassVarConflict(classTypeResult.classType);
+            }
+            this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.name);
+            this._validateConstructorConsistency(classTypeResult.classType);
+            this._validateFinalMemberOverrides(classTypeResult.classType);
+            this._validateInstanceVariableInitialization(classTypeResult.classType);
+            this._validateFinalClassNotAbstract(classTypeResult.classType, node);
+            this._validateDataClassPostInit(classTypeResult.classType, node);
+            this._validateProtocolCompatibility(classTypeResult.classType, node);
+            this._reportDuplicateEnumMembers(classTypeResult.classType);
+            if (types_1.ClassType.isTypedDictClass(classTypeResult.classType)) {
+                this._validateTypedDictClassSuite(node.suite);
+            }
+            if (types_1.ClassType.isEnumClass(classTypeResult.classType)) {
+                this._validateEnumClassOverride(node, classTypeResult.classType);
+            }
+        }
+        this._scopedNodes.push(node);
+        return false;
+    }
+    visitFunction(node) {
+        var _a;
+        const functionTypeResult = this._evaluator.getTypeOfFunction(node);
+        const containingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
+        if (functionTypeResult) {
+            // Track whether we have seen a *args: P.args parameter. Named
+            // parameters after this need to be flagged as an error.
+            let sawParamSpecArgs = false;
+            // Report any unknown or missing parameter types.
+            node.parameters.forEach((param, index) => {
+                if (param.name) {
+                    // Determine whether this is a P.args parameter.
+                    if (param.category === 1 /* VarArgList */) {
+                        const annotationExpr = param.typeAnnotation || param.typeAnnotationComment;
+                        if (annotationExpr &&
+                            annotationExpr.nodeType === 35 /* MemberAccess */ &&
+                            annotationExpr.memberName.value === 'args') {
+                            const baseType = this._evaluator.getType(annotationExpr.leftExpression);
+                            if (baseType && (0, types_1.isTypeVar)(baseType) && baseType.details.isParamSpec) {
+                                sawParamSpecArgs = true;
+                            }
+                        }
+                    }
+                    else if (param.category === 2 /* VarArgDictionary */) {
+                        sawParamSpecArgs = false;
+                    }
+                }
+                if (param.name && param.category === 0 /* Simple */ && sawParamSpecArgs) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.namedParamAfterParamSpecArgs().format({ name: param.name.value }), param.name);
+                }
+                // Allow unknown and missing param types if the param is named '_'.
+                if (param.name && param.name.value !== '_') {
+                    const functionTypeParam = functionTypeResult.functionType.details.parameters.find((p) => { var _a; return p.name === ((_a = param.name) === null || _a === void 0 ? void 0 : _a.value); });
+                    if (functionTypeParam) {
+                        const paramType = functionTypeParam.type;
+                        if ((0, types_1.isUnknown)(paramType) ||
+                            ((0, types_1.isTypeVar)(paramType) &&
+                                paramType.details.isSynthesized &&
+                                !paramType.details.isSynthesizedSelf)) {
+                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.paramTypeUnknown().format({ paramName: param.name.value }), param.name);
+                        }
+                        else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
+                            const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.paramType().format({
+                                paramType: this._evaluator.printType(paramType, /* expandTypeAlias */ true),
+                            }));
+                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.paramTypePartiallyUnknown().format({
+                                paramName: param.name.value,
+                            }) + diagAddendum.getString(), param.name);
+                        }
+                        let hasAnnotation = false;
+                        if (functionTypeParam.typeAnnotation) {
+                            hasAnnotation = true;
+                        }
+                        else {
+                            // See if this is a "self" and "cls" parameter. They are exempt from this rule.
+                            if ((0, types_1.isTypeVar)(paramType) && paramType.details.isSynthesizedSelf) {
+                                hasAnnotation = true;
+                            }
+                        }
+                        if (!hasAnnotation) {
+                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingParameterType, diagnosticRules_1.DiagnosticRule.reportMissingParameterType, localize_1.Localizer.Diagnostic.paramAnnotationMissing().format({ name: param.name.value }), param.name);
+                        }
+                    }
+                }
+                // If it's a stub file, report an issue of the default value expression is not "...".
+                if (param.defaultValue && this._fileInfo.isStubFile) {
+                    const defaultValueType = this._evaluator.getType(param.defaultValue);
+                    if (!defaultValueType || !(0, typeUtils_1.isEllipsisType)(defaultValueType)) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidStubStatement, diagnosticRules_1.DiagnosticRule.reportInvalidStubStatement, localize_1.Localizer.Diagnostic.defaultValueNotEllipsis(), param.defaultValue);
+                    }
+                }
+            });
+            // Check for invalid use of ParamSpec P.args and P.kwargs.
+            const paramSpecParams = functionTypeResult.functionType.details.parameters.filter((param) => {
+                if (param.typeAnnotation && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
+                    if (param.category !== 0 /* Simple */ && param.name && param.type.paramSpecAccess) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+            if (paramSpecParams.length === 1 && paramSpecParams[0].typeAnnotation) {
+                this._evaluator.addError(localize_1.Localizer.Diagnostic.paramSpecArgsKwargsUsage(), paramSpecParams[0].typeAnnotation);
+            }
+            // If this is a stub, ensure that the return type is specified.
+            if (this._fileInfo.isStubFile) {
+                const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
+                if (!returnAnnotation) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.name);
+                }
+            }
+            if (containingClassNode) {
+                this._validateMethod(node, functionTypeResult.functionType, containingClassNode);
+            }
+        }
+        node.parameters.forEach((param, index) => {
+            if (param.defaultValue) {
+                this.walk(param.defaultValue);
+            }
+            if (param.typeAnnotation) {
+                this.walk(param.typeAnnotation);
+            }
+            if (param.typeAnnotationComment) {
+                this.walk(param.typeAnnotationComment);
+            }
+            if (functionTypeResult) {
+                const annotationNode = param.typeAnnotation || param.typeAnnotationComment;
+                if (annotationNode && index < functionTypeResult.functionType.details.parameters.length) {
+                    const paramType = functionTypeResult.functionType.details.parameters[index].type;
+                    if ((0, types_1.isTypeVar)(paramType) &&
+                        paramType.details.variance === 1 /* Covariant */ &&
+                        !paramType.details.isSynthesized &&
+                        functionTypeResult.functionType.details.name !== '__init__') {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramTypeCovariant(), annotationNode);
+                    }
+                }
+            }
+        });
+        if (node.returnTypeAnnotation) {
+            this.walk(node.returnTypeAnnotation);
+        }
+        if (node.functionAnnotationComment) {
+            this.walk(node.functionAnnotationComment);
+            if (this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage !== 'none' &&
+                this._fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_5) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage, diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.Localizer.Diagnostic.typeCommentDeprecated(), node.functionAnnotationComment);
+            }
+        }
+        this.walkMultiple(node.decorators);
+        node.parameters.forEach((param) => {
+            if (param.name) {
+                this.walk(param.name);
+            }
+        });
+        const codeComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(node);
+        const isTooComplexToAnalyze = codeComplexity > typeEvaluator_1.maxCodeComplexity;
+        if (isPrintCodeComplexityEnabled) {
+            console.log(`Code complexity of function ${node.name.value} is ${codeComplexity.toString()}`);
+        }
+        if (isTooComplexToAnalyze) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.codeTooComplexToAnalyze(), node.name);
+        }
+        else {
+            this.walk(node.suite);
+        }
+        if (functionTypeResult) {
+            // Validate that the function returns the declared type.
+            if (!isTooComplexToAnalyze) {
+                this._validateFunctionReturn(node, functionTypeResult.functionType);
+            }
+            // Verify common dunder signatures.
+            this._validateDunderSignatures(node, functionTypeResult.functionType, containingClassNode !== undefined);
+            // Verify that strict type guard functions don't violate the constraints
+            // of strict type guards.
+            this._validateStrictTypeGuardFunction(node, functionTypeResult.functionType, containingClassNode !== undefined);
+            this._validateFunctionTypeVarUsage(node, functionTypeResult.functionType);
+        }
+        // If we're at the module level within a stub file, report a diagnostic
+        // if there is a '__getattr__' function defined when in strict mode.
+        // This signifies an incomplete stub file that obscures type errors.
+        if (this._fileInfo.isStubFile && node.name.value === '__getattr__') {
+            const scope = (0, scopeUtils_1.getScopeForNode)(node);
+            if ((scope === null || scope === void 0 ? void 0 : scope.type) === 3 /* Module */) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompleteStub, diagnosticRules_1.DiagnosticRule.reportIncompleteStub, localize_1.Localizer.Diagnostic.stubUsesGetAttr(), node.name);
+            }
+        }
+        this._scopedNodes.push(node);
+        if (functionTypeResult && (0, types_1.isOverloadedFunction)(functionTypeResult.decoratedType)) {
+            const overloads = functionTypeResult.decoratedType.overloads;
+            if (overloads.length > 1) {
+                const maxOverloadConsistencyCheckLength = 100;
+                // The check is n^2 in time, so if the number of overloads
+                // is very large (which can happen for some generated code),
+                // skip this check to avoid quadratic analysis time.
+                if (overloads.length < maxOverloadConsistencyCheckLength) {
+                    this._validateOverloadConsistency(node, overloads[overloads.length - 1], overloads.slice(0, overloads.length - 1));
+                }
+            }
+        }
+        return false;
+    }
+    visitLambda(node) {
+        this._evaluator.getType(node);
+        // Walk the children.
+        this.walkMultiple([...node.parameters, node.expression]);
+        node.parameters.forEach((param) => {
+            if (param.name) {
+                const paramType = this._evaluator.getType(param.name);
+                if (paramType) {
+                    if ((0, types_1.isUnknown)(paramType)) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownLambdaType, diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.Localizer.Diagnostic.paramTypeUnknown().format({ paramName: param.name.value }), param.name);
+                    }
+                    else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownLambdaType, diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.Localizer.Diagnostic.paramTypePartiallyUnknown().format({ paramName: param.name.value }), param.name);
+                    }
+                }
+            }
+        });
+        const returnType = this._evaluator.getType(node.expression);
+        if (returnType) {
+            if ((0, types_1.isUnknown)(returnType)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownLambdaType, diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.Localizer.Diagnostic.lambdaReturnTypeUnknown(), node.expression);
+            }
+            else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownLambdaType, diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.Localizer.Diagnostic.lambdaReturnTypePartiallyUnknown().format({
+                    returnType: this._evaluator.printType(returnType, /* expandTypeAlias */ true),
+                }), node.expression);
+            }
+        }
+        this._scopedNodes.push(node);
+        return false;
+    }
+    visitCall(node) {
+        var _a;
+        this._validateIsInstanceCall(node);
+        this._validateIllegalDefaultParamInitializer(node);
+        if (this._fileInfo.diagnosticRuleSet.reportUnusedCallResult !== 'none' ||
+            this._fileInfo.diagnosticRuleSet.reportUnusedCoroutine !== 'none') {
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* StatementList */) {
+                const isRevealTypeCall = node.leftExpression.nodeType === 38 /* Name */ && node.leftExpression.value === 'reveal_type';
+                const returnType = this._evaluator.getType(node);
+                if (!isRevealTypeCall && returnType && this._isTypeValidForUnusedValueTest(returnType)) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCallResult, diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.Localizer.Diagnostic.unusedCallResult().format({
+                        type: this._evaluator.printType(returnType, /* expandTypeAlias */ false),
+                    }), node);
+                    if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, 'Coroutine')) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCoroutine, diagnosticRules_1.DiagnosticRule.reportUnusedCoroutine, localize_1.Localizer.Diagnostic.unusedCoroutine(), node);
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    visitAwait(node) {
+        var _a;
+        if (this._fileInfo.diagnosticRuleSet.reportUnusedCallResult !== 'none') {
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* StatementList */ &&
+                node.expression.nodeType === 9 /* Call */) {
+                const returnType = this._evaluator.getType(node);
+                if (returnType && this._isTypeValidForUnusedValueTest(returnType)) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedCallResult, diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.Localizer.Diagnostic.unusedCallResult().format({
+                        type: this._evaluator.printType(returnType, /* expandTypeAlias */ false),
+                    }), node);
+                }
+            }
+        }
+        return true;
+    }
+    visitFor(node) {
+        this._evaluator.evaluateTypesForStatement(node);
+        return true;
+    }
+    visitList(node) {
+        this._validateIllegalDefaultParamInitializer(node);
+        return true;
+    }
+    visitSet(node) {
+        this._validateIllegalDefaultParamInitializer(node);
+        return true;
+    }
+    visitDictionary(node) {
+        this._validateIllegalDefaultParamInitializer(node);
+        return true;
+    }
+    visitListComprehension(node) {
+        this._scopedNodes.push(node);
+        return true;
+    }
+    visitListComprehensionIf(node) {
+        this._reportUnnecessaryConditionExpression(node.testExpression);
+        return true;
+    }
+    visitIf(node) {
+        this._evaluator.getType(node.testExpression);
+        this._reportUnnecessaryConditionExpression(node.testExpression);
+        return true;
+    }
+    visitWhile(node) {
+        this._evaluator.getType(node.testExpression);
+        this._reportUnnecessaryConditionExpression(node.testExpression);
+        return true;
+    }
+    visitWith(node) {
+        node.withItems.forEach((item) => {
+            this._evaluator.evaluateTypesForStatement(item);
+        });
+        return true;
+    }
+    visitReturn(node) {
+        let returnType;
+        const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
+        const declaredReturnType = enclosingFunctionNode
+            ? this._evaluator.getFunctionDeclaredReturnType(enclosingFunctionNode)
+            : undefined;
+        if (node.returnExpression) {
+            returnType = this._evaluator.getType(node.returnExpression) || types_1.UnknownType.create();
+        }
+        else {
+            // There is no return expression, so "None" is assumed.
+            returnType = types_1.NoneType.createInstance();
+        }
+        if (this._evaluator.isNodeReachable(node, /* sourceNode */ undefined) && enclosingFunctionNode) {
+            if (declaredReturnType) {
+                if ((0, types_1.isNever)(declaredReturnType)) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noReturnContainsReturn(), node);
+                }
+                else {
+                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    let returnTypeMatches = false;
+                    if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, new typeVarContext_1.TypeVarContext(), 
+                    /* srcTypeVarContext */ undefined, 64 /* AllowBoolTypeGuard */)) {
+                        returnTypeMatches = true;
+                    }
+                    else {
+                        // See if the declared return type includes one or more constrained TypeVars. If so,
+                        // try to narrow these TypeVars to a single type.
+                        const uniqueTypeVars = (0, typeUtils_1.getTypeVarArgumentsRecursive)(declaredReturnType);
+                        if (uniqueTypeVars &&
+                            uniqueTypeVars.some((typeVar) => typeVar.details.constraints.length > 0)) {
+                            const typeVarContext = new typeVarContext_1.TypeVarContext();
+                            for (const typeVar of uniqueTypeVars) {
+                                if (typeVar.details.constraints.length > 0) {
+                                    const narrowedType = this._evaluator.narrowConstrainedTypeVar(node, typeVar);
+                                    if (narrowedType) {
+                                        typeVarContext.setTypeVarType(typeVar, narrowedType);
+                                        typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(typeVar));
+                                    }
+                                }
+                            }
+                            if (!typeVarContext.isEmpty()) {
+                                const adjustedReturnType = (0, typeUtils_1.applySolvedTypeVars)(declaredReturnType, typeVarContext);
+                                if (this._evaluator.assignType(adjustedReturnType, returnType, diagAddendum, 
+                                /* destTypeVarContext */ undefined, 
+                                /* srcTypeVarContext */ undefined, 64 /* AllowBoolTypeGuard */)) {
+                                    returnTypeMatches = true;
+                                }
+                            }
+                        }
+                    }
+                    if (!returnTypeMatches) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeMismatch().format({
+                            exprType: this._evaluator.printType(returnType, /* expandTypeAlias */ false),
+                            returnType: this._evaluator.printType(declaredReturnType, /* expandTypeAlias */ false),
+                        }) + diagAddendum.getString(), node.returnExpression ? node.returnExpression : node);
+                    }
+                }
+            }
+            if ((0, types_1.isUnknown)(returnType)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.returnExpression);
+            }
+            else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypePartiallyUnknown().format({
+                    returnType: this._evaluator.printType(returnType, /* expandTypeAlias */ true),
+                }), node.returnExpression);
+            }
+        }
+        return true;
+    }
+    visitYield(node) {
+        const yieldType = node.expression ? this._evaluator.getType(node.expression) : types_1.NoneType.createInstance();
+        this._validateYieldType(node, yieldType || types_1.UnknownType.create());
+        return true;
+    }
+    visitYieldFrom(node) {
+        const yieldFromType = this._evaluator.getType(node.expression) || types_1.UnknownType.create();
+        let yieldType;
+        if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, 'Coroutine')) {
+            // Handle the case of old-style (pre-await) coroutines.
+            yieldType = types_1.UnknownType.create();
+        }
+        else {
+            yieldType =
+                this._evaluator.getTypeOfIterable(yieldFromType, /* isAsync */ false, node) || types_1.UnknownType.create();
+            // Does the iterator return a Generator? If so, get the yield type from it.
+            // If the iterator doesn't return a Generator, use the iterator return type
+            // directly.
+            const generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(yieldType);
+            if (generatorTypeArgs) {
+                yieldType = generatorTypeArgs.length >= 1 ? generatorTypeArgs[0] : types_1.UnknownType.create();
+            }
+            else {
+                yieldType =
+                    this._evaluator.getTypeOfIterator(yieldFromType, /* isAsync */ false, node) || types_1.UnknownType.create();
+            }
+        }
+        this._validateYieldType(node, yieldType);
+        return true;
+    }
+    visitRaise(node) {
+        this._evaluator.verifyRaiseExceptionType(node);
+        if (node.valueExpression) {
+            const baseExceptionType = this._evaluator.getBuiltInType(node, 'BaseException');
+            const exceptionType = this._evaluator.getType(node.valueExpression);
+            // Validate that the argument of "raise" is an exception object or None.
+            if (exceptionType && baseExceptionType && (0, types_1.isInstantiableClass)(baseExceptionType)) {
+                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                (0, typeUtils_1.doForEachSubtype)(exceptionType, (subtype) => {
+                    subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
+                    if (!(0, types_1.isAnyOrUnknown)(subtype) && !(0, types_1.isNoneInstance)(subtype)) {
+                        if ((0, types_1.isClass)(subtype)) {
+                            if (!(0, typeUtils_1.derivesFromClassRecursive)(subtype, baseExceptionType, /* ignoreUnknown */ false)) {
+                                diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                                    type: this._evaluator.printType(subtype, /* expandTypeAlias */ false),
+                                }));
+                            }
+                        }
+                        else {
+                            diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                                type: this._evaluator.printType(subtype, /* expandTypeAlias */ false),
+                            }));
+                        }
+                    }
+                });
+                if (!diagAddendum.isEmpty()) {
+                    this._evaluator.addError(localize_1.Localizer.Diagnostic.expectedExceptionObj() + diagAddendum.getString(), node.valueExpression);
+                }
+            }
+        }
+        return true;
+    }
+    visitExcept(node) {
+        if (node.typeExpression) {
+            this._evaluator.evaluateTypesForStatement(node);
+            const exceptionType = this._evaluator.getType(node.typeExpression);
+            if (exceptionType) {
+                this._validateExceptionType(exceptionType, node.typeExpression);
+            }
+        }
+        return true;
+    }
+    visitAssert(node) {
+        if (node.exceptionExpression) {
+            this._evaluator.getType(node.exceptionExpression);
+        }
+        // Specifically look for a common programming error where the two arguments
+        // to an assert are enclosed in parens and interpreted as a two-element tuple.
+        //   assert (x > 3, "bad value x")
+        const type = this._evaluator.getType(node.testExpression);
+        if (type && (0, types_1.isClassInstance)(type)) {
+            if ((0, typeUtils_1.isTupleClass)(type) && type.tupleTypeArguments) {
+                if (type.tupleTypeArguments.length > 0) {
+                    if (!(0, typeUtils_1.isUnboundedTupleClass)(type)) {
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportAssertAlwaysTrue, diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue, localize_1.Localizer.Diagnostic.assertAlwaysTrue(), node.testExpression);
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    visitAssignment(node) {
+        this._evaluator.evaluateTypesForStatement(node);
+        if (node.typeAnnotationComment) {
+            this._evaluator.getType(node.typeAnnotationComment);
+            if (this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage !== 'none' &&
+                this._fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_6) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage, diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.Localizer.Diagnostic.typeCommentDeprecated(), node.typeAnnotationComment);
+            }
+        }
+        return true;
+    }
+    visitAssignmentExpression(node) {
+        this._evaluator.getType(node);
+        return true;
+    }
+    visitAugmentedAssignment(node) {
+        this._evaluator.evaluateTypesForStatement(node);
+        return true;
+    }
+    visitIndex(node) {
+        this._evaluator.getType(node);
+        // If the index is a literal integer, see if this is a tuple with
+        // a known length and the integer value exceeds the length.
+        const baseType = this._evaluator.getType(node.baseExpression);
+        if (baseType) {
+            (0, typeUtils_1.doForEachSubtype)(baseType, (subtype) => {
+                if ((0, types_1.isClassInstance)(subtype) && subtype.tupleTypeArguments && !(0, typeUtils_1.isUnboundedTupleClass)(subtype)) {
+                    const tupleLength = subtype.tupleTypeArguments.length;
+                    if (node.items.length === 1 &&
+                        !node.trailingComma &&
+                        node.items[0].argumentCategory === 0 /* Simple */ &&
+                        !node.items[0].name) {
+                        const subscriptType = this._evaluator.getType(node.items[0].valueExpression);
+                        if (subscriptType &&
+                            (0, types_1.isClassInstance)(subscriptType) &&
+                            types_1.ClassType.isBuiltIn(subscriptType, 'int') &&
+                            (0, typeUtils_1.isLiteralType)(subscriptType) &&
+                            typeof subscriptType.literalValue === 'number') {
+                            if ((subscriptType.literalValue >= 0 && subscriptType.literalValue >= tupleLength) ||
+                                (subscriptType.literalValue < 0 && subscriptType.literalValue + tupleLength < 0)) {
+                                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.tupleIndexOutOfRange().format({
+                                    index: subscriptType.literalValue,
+                                    type: this._evaluator.printType(subtype),
+                                }), node);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return true;
+    }
+    visitBinaryOperation(node) {
+        if (node.operator === 12 /* Equals */ || node.operator === 28 /* NotEquals */) {
+            // Don't apply this rule if it's within an assert.
+            if (!ParseTreeUtils.isWithinAssertExpression(node)) {
+                this._validateComparisonTypes(node);
+            }
+        }
+        this._evaluator.getType(node);
+        return true;
+    }
+    visitSlice(node) {
+        this._evaluator.getType(node);
+        return true;
+    }
+    visitUnpack(node) {
+        this._evaluator.getType(node);
+        return true;
+    }
+    visitTuple(node) {
+        this._evaluator.getType(node);
+        return true;
+    }
+    visitUnaryOperation(node) {
+        this._evaluator.getType(node);
+        return true;
+    }
+    visitTernary(node) {
+        this._evaluator.getType(node);
+        this._reportUnnecessaryConditionExpression(node.testExpression);
+        return true;
+    }
+    visitStringList(node) {
+        for (const stringNode of node.strings) {
+            if (stringNode.hasUnescapeErrors) {
+                const unescapedResult = (0, stringTokenUtils_1.getUnescapedString)(stringNode.token);
+                unescapedResult.unescapeErrors.forEach((error) => {
+                    const start = stringNode.token.start +
+                        stringNode.token.prefixLength +
+                        stringNode.token.quoteMarkLength +
+                        error.offset;
+                    const textRange = { start, length: error.length };
+                    if (error.errorType === 0 /* InvalidEscapeSequence */) {
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportInvalidStringEscapeSequence, diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence, localize_1.Localizer.Diagnostic.stringUnsupportedEscape(), textRange);
+                    }
+                    else if (error.errorType === 1 /* EscapeWithinFormatExpression */) {
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, 'error', '', localize_1.Localizer.Diagnostic.formatStringEscape(), textRange);
+                    }
+                    else if (error.errorType === 2 /* SingleCloseBraceWithinFormatLiteral */) {
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, 'error', '', localize_1.Localizer.Diagnostic.formatStringBrace(), textRange);
+                    }
+                    else if (error.errorType === 3 /* UnterminatedFormatExpression */) {
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, 'error', '', localize_1.Localizer.Diagnostic.formatStringUnterminated(), textRange);
+                    }
+                });
+            }
+        }
+        if (node.typeAnnotation) {
+            this._evaluator.getType(node);
+        }
+        if (node.strings.length > 1 && !node.isParenthesized) {
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportImplicitStringConcatenation, diagnosticRules_1.DiagnosticRule.reportImplicitStringConcatenation, localize_1.Localizer.Diagnostic.implicitStringConcat(), node);
+        }
+        return true;
+    }
+    visitFormatString(node) {
+        node.expressions.forEach((formatExpr) => {
+            this._evaluator.getType(formatExpr);
+        });
+        return true;
+    }
+    visitGlobal(node) {
+        this._suppressUnboundCheck(() => {
+            node.nameList.forEach((name) => {
+                this._evaluator.getType(name);
+                this.walk(name);
+            });
+        });
+        return false;
+    }
+    visitNonlocal(node) {
+        this._suppressUnboundCheck(() => {
+            node.nameList.forEach((name) => {
+                this._evaluator.getType(name);
+                this.walk(name);
+            });
+        });
+        return false;
+    }
+    visitName(node) {
+        // Determine if we should log information about private usage.
+        this._conditionallyReportPrivateUsage(node);
+        // Determine if the name is possibly unbound.
+        if (!this._isUnboundCheckSuppressed) {
+            this._reportUnboundName(node);
+        }
+        // Report the use of a deprecated symbol. For now, this functionality
+        // is disabled. We'll leave it in place for the future.
+        // this._reportDeprecatedUse(node);
+        return true;
+    }
+    visitDel(node) {
+        this._suppressUnboundCheck(() => {
+            node.expressions.forEach((expr) => {
+                this._evaluator.verifyDeleteExpression(expr);
+                this.walk(expr);
+            });
+        });
+        return false;
+    }
+    visitMemberAccess(node) {
+        this._evaluator.getType(node);
+        this._conditionallyReportPrivateUsage(node.memberName);
+        // Walk the leftExpression but not the memberName.
+        this.walk(node.leftExpression);
+        return false;
+    }
+    visitImportAs(node) {
+        this._evaluator.evaluateTypesForStatement(node);
+        return false;
+    }
+    visitImportFrom(node) {
+        if (!node.isWildcardImport) {
+            node.imports.forEach((importAs) => {
+                this._evaluator.evaluateTypesForStatement(importAs);
+            });
+        }
+        else {
+            const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
+            if (importInfo &&
+                importInfo.isImportFound &&
+                importInfo.importType !== 2 /* Local */ &&
+                !this._fileInfo.isStubFile) {
+                this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportWildcardImportFromLibrary, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.Localizer.Diagnostic.wildcardLibraryImport(), node.wildcardToken || node);
+            }
+        }
+        return false;
+    }
+    visitTypeAnnotation(node) {
+        this._evaluator.getType(node.typeAnnotation);
+        return true;
+    }
+    visitMatch(node) {
+        this._evaluator.getType(node.subjectExpression);
+        this._validateExhaustiveMatch(node);
+        return true;
+    }
+    visitCase(node) {
+        if (node.guardExpression) {
+            this._evaluator.getType(node.guardExpression);
+        }
+        this._evaluator.evaluateTypesForStatement(node.pattern);
+        return true;
+    }
+    visitPatternClass(node) {
+        (0, patternMatching_1.validateClassPattern)(this._evaluator, node);
+        return true;
+    }
+    visitTry(node) {
+        this._reportUnusedExceptStatements(node);
+        return true;
+    }
+    visitError(node) {
+        // Get the type of the child so it's available to
+        // the completion provider.
+        if (node.child) {
+            this._evaluator.getType(node.child);
+        }
+        // Don't explore further.
+        return false;
+    }
+    _reportUnnecessaryConditionExpression(expression) {
+        if (expression.nodeType === 7 /* BinaryOperation */) {
+            if (expression.operator === 36 /* And */ || expression.operator === 37 /* Or */) {
+                this._reportUnnecessaryConditionExpression(expression.leftExpression);
+                this._reportUnnecessaryConditionExpression(expression.rightExpression);
+            }
+            return;
+        }
+        else if (expression.nodeType === 55 /* UnaryOperation */) {
+            if (expression.operator === 38 /* Not */) {
+                this._reportUnnecessaryConditionExpression(expression.expression);
+            }
+            return;
+        }
+        const exprTypeResult = this._evaluator.getTypeOfExpression(expression);
+        let isExprFunction = true;
+        (0, typeUtils_1.doForEachSubtype)(exprTypeResult.type, (subtype) => {
+            subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
+            if (!(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloadedFunction)(subtype)) {
+                isExprFunction = false;
+            }
+        });
+        if (isExprFunction) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, localize_1.Localizer.Diagnostic.functionInConditionalExpression(), expression);
+        }
+    }
+    _reportUnusedExpression(node) {
+        if (this._fileInfo.diagnosticRuleSet.reportUnusedExpression === 'none') {
+            return;
+        }
+        const simpleExpressionTypes = [
+            55 /* UnaryOperation */,
+            7 /* BinaryOperation */,
+            40 /* Number */,
+            11 /* Constant */,
+            38 /* Name */,
+        ];
+        if (simpleExpressionTypes.some((nodeType) => nodeType === node.nodeType)) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnusedExpression, diagnosticRules_1.DiagnosticRule.reportUnusedExpression, localize_1.Localizer.Diagnostic.unusedExpression(), node);
+        }
+    }
+    _validateExhaustiveMatch(node) {
+        // This check can be expensive, so skip it if it's disabled.
+        if (this._fileInfo.diagnosticRuleSet.reportMatchNotExhaustive === 'none') {
+            return;
+        }
+        const narrowedTypeResult = this._evaluator.evaluateTypeForSubnode(node, () => {
+            this._evaluator.evaluateTypesForMatchStatement(node);
+        });
+        if (narrowedTypeResult && !(0, types_1.isNever)(narrowedTypeResult.type)) {
+            const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.matchIsNotExhaustiveType().format({
+                type: this._evaluator.printType(narrowedTypeResult.type),
+            }));
+            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.matchIsNotExhaustiveHint());
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMatchNotExhaustive, diagnosticRules_1.DiagnosticRule.reportMatchNotExhaustive, localize_1.Localizer.Diagnostic.matchIsNotExhaustive() + diagAddendum.getString(), node.subjectExpression);
+        }
+    }
+    _suppressUnboundCheck(callback) {
+        const wasSuppressed = this._isUnboundCheckSuppressed;
+        this._isUnboundCheckSuppressed = true;
+        try {
+            callback();
+        }
+        finally {
+            this._isUnboundCheckSuppressed = wasSuppressed;
+        }
+    }
+    _validateIllegalDefaultParamInitializer(node) {
+        if (this._fileInfo.diagnosticRuleSet.reportCallInDefaultInitializer !== 'none') {
+            if (ParseTreeUtils.isWithinDefaultParamInitializer(node) && !this._fileInfo.isStubFile) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportCallInDefaultInitializer, diagnosticRules_1.DiagnosticRule.reportCallInDefaultInitializer, localize_1.Localizer.Diagnostic.defaultValueContainsCall(), node);
+            }
+        }
+    }
+    // Determines whether the types of the two operands for an == or != operation
+    // have overlapping types.
+    _validateComparisonTypes(node) {
+        const leftType = this._evaluator.getType(node.leftExpression);
+        const rightType = this._evaluator.getType(node.rightExpression);
+        if (!leftType || !rightType) {
+            return;
+        }
+        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
+            return;
+        }
+        const getMessage = () => {
+            return node.operator === 12 /* Equals */
+                ? localize_1.Localizer.Diagnostic.comparisonAlwaysFalse()
+                : localize_1.Localizer.Diagnostic.comparisonAlwaysTrue();
+        };
+        // Check for the special case where the LHS and RHS are both literals.
+        if ((0, typeUtils_1.isLiteralTypeOrUnion)(rightType) && (0, typeUtils_1.isLiteralTypeOrUnion)(leftType)) {
+            if ((0, staticExpressions_1.evaluateStaticBoolExpression)(node, this._fileInfo.executionEnvironment, this._fileInfo.definedConstants) === undefined) {
+                let isPossiblyTrue = false;
+                (0, typeUtils_1.doForEachSubtype)(leftType, (leftSubtype) => {
+                    if (this._evaluator.assignType(rightType, leftSubtype)) {
+                        isPossiblyTrue = true;
+                    }
+                });
+                if (!isPossiblyTrue) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
+                        leftType: this._evaluator.printType(leftType, /* expandTypeAlias */ true),
+                        rightType: this._evaluator.printType(rightType, /* expandTypeAlias */ true),
+                    }), node);
+                }
+            }
+        }
+        else {
+            let isComparable = false;
+            (0, typeUtils_1.doForEachSubtype)(leftType, (leftSubtype) => {
+                if (isComparable) {
+                    return;
+                }
+                leftSubtype = this._evaluator.makeTopLevelTypeVarsConcrete(leftSubtype);
+                (0, typeUtils_1.doForEachSubtype)(rightType, (rightSubtype) => {
+                    if (isComparable) {
+                        return;
+                    }
+                    rightSubtype = this._evaluator.makeTopLevelTypeVarsConcrete(rightSubtype);
+                    if (this._isTypeComparable(leftSubtype, rightSubtype)) {
+                        isComparable = true;
+                    }
+                });
+            });
+            if (!isComparable) {
+                const leftTypeText = this._evaluator.printType(leftType, /* expandTypeAlias */ true);
+                const rightTypeText = this._evaluator.printType(rightType, /* expandTypeAlias */ true);
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
+                    leftType: leftTypeText,
+                    rightType: rightTypeText,
+                }), node);
+            }
+        }
+    }
+    // Determines whether the two types are potentially comparable -- i.e.
+    // their types overlap in such a way that it makes sense for them to
+    // be compared with an == or != operator.
+    _isTypeComparable(leftType, rightType) {
+        if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
+            return true;
+        }
+        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
+            return false;
+        }
+        if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
+            return (0, types_1.isTypeSame)(leftType, rightType);
+        }
+        if ((0, types_1.isNoneInstance)(leftType) || (0, types_1.isNoneInstance)(rightType)) {
+            return (0, types_1.isTypeSame)(leftType, rightType);
+        }
+        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloadedFunction)(leftType);
+        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloadedFunction)(rightType);
+        if (isLeftCallable !== isRightCallable) {
+            return false;
+        }
+        if ((0, types_1.isInstantiableClass)(leftType) || ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'type'))) {
+            if ((0, types_1.isInstantiableClass)(rightType) ||
+                ((0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, 'type'))) {
+                const genericLeftType = types_1.ClassType.cloneForSpecialization(leftType, 
+                /* typeArguments */ undefined, 
+                /* isTypeArgumentExplicit */ false);
+                const genericRightType = types_1.ClassType.cloneForSpecialization(rightType, 
+                /* typeArguments */ undefined, 
+                /* isTypeArgumentExplicit */ false);
+                if (this._evaluator.assignType(genericLeftType, genericRightType) ||
+                    this._evaluator.assignType(genericRightType, genericLeftType)) {
+                    return true;
+                }
+            }
+            // Does the class have an operator overload for eq?
+            const metaclass = leftType.details.effectiveMetaclass;
+            if (metaclass && (0, types_1.isClass)(metaclass)) {
+                if ((0, typeUtils_1.lookUpClassMember)(metaclass, '__eq__', 4 /* SkipObjectBaseClass */)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if ((0, types_1.isClassInstance)(leftType)) {
+            if ((0, types_1.isClassInstance)(rightType)) {
+                const genericLeftType = types_1.ClassType.cloneForSpecialization(leftType, 
+                /* typeArguments */ undefined, 
+                /* isTypeArgumentExplicit */ false);
+                const genericRightType = types_1.ClassType.cloneForSpecialization(rightType, 
+                /* typeArguments */ undefined, 
+                /* isTypeArgumentExplicit */ false);
+                if (this._evaluator.assignType(genericLeftType, genericRightType) ||
+                    this._evaluator.assignType(genericRightType, genericLeftType)) {
+                    return true;
+                }
+                // Assume that if the types are disjoint and built-in classes that they
+                // will never be comparable.
+                if (types_1.ClassType.isBuiltIn(leftType) && types_1.ClassType.isBuiltIn(rightType)) {
+                    return false;
+                }
+            }
+            // Does the class have an operator overload for eq?
+            if ((0, typeUtils_1.lookUpClassMember)(types_1.ClassType.cloneAsInstantiable(leftType), '__eq__', 4 /* SkipObjectBaseClass */)) {
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
+    // Determines whether the specified type is one that should trigger
+    // an "unused" value diagnostic.
+    _isTypeValidForUnusedValueTest(type) {
+        return !(0, types_1.isNoneInstance)(type) && !(0, types_1.isNever)(type) && !(0, types_1.isAnyOrUnknown)(type);
+    }
+    // Verifies that each local type variable is used more than once.
+    _validateFunctionTypeVarUsage(node, type) {
+        // Skip this check entirely if it's disabled.
+        if (this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse === 'none') {
+            return;
+        }
+        const localTypeVarUsage = new Map();
+        const classTypeVarUsage = new Map();
+        let exemptBoundTypeVar = true;
+        let curParamNode;
+        // Is this a constructor (an __init__ method) for a generic class?
+        let constructorClass;
+        if (types_1.FunctionType.isInstanceMethod(type) && node.name.value === '__init__') {
+            const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(node);
+            if (containingClassNode && containingClassNode.nodeType === 10 /* Class */) {
+                const classType = this._evaluator.getTypeOfClass(containingClassNode);
+                if (classType && (0, types_1.isClass)(classType.classType)) {
+                    constructorClass = classType.classType;
+                }
+            }
+        }
+        const nameWalker = new ParseTreeUtils.NameNodeWalker((nameNode, subscriptIndex, baseExpression) => {
+            var _a, _b, _c, _d, _e, _f;
+            const nameType = this._evaluator.getType(nameNode);
+            ``;
+            if (nameType && (0, types_1.isTypeVar)(nameType)) {
+                // Does this name refer to a TypeVar that is scoped to this function?
+                if (nameType.scopeId === this._evaluator.getScopeIdForNode(node)) {
+                    // We exempt constrained TypeVars, bound TypeVars that are type arguments of
+                    // other types, and ParamSpecs. There are legitimate uses for singleton
+                    // instances in these particular cases.
+                    let isExempt = nameType.details.constraints.length > 0 ||
+                        (exemptBoundTypeVar &&
+                            nameType.details.boundType !== undefined &&
+                            subscriptIndex !== undefined) ||
+                        (0, types_1.isParamSpec)(nameType);
+                    if (!isExempt && baseExpression && subscriptIndex !== undefined) {
+                        // Is this a type argument for a generic type alias? If so,
+                        // exempt it from the check because the type alias may repeat
+                        // the TypeVar multiple times.
+                        const baseType = this._evaluator.getType(baseExpression);
+                        if ((baseType === null || baseType === void 0 ? void 0 : baseType.typeAliasInfo) &&
+                            baseType.typeAliasInfo.typeParameters &&
+                            subscriptIndex < baseType.typeAliasInfo.typeParameters.length) {
+                            isExempt = true;
+                        }
+                    }
+                    const existingEntry = localTypeVarUsage.get(nameType.details.name);
+                    const isParamTypeWithEllipsisUsage = ((_a = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _a === void 0 ? void 0 : _a.nodeType) === 18 /* Ellipsis */;
+                    if (!existingEntry) {
+                        localTypeVarUsage.set(nameType.details.name, {
+                            nodes: [nameNode],
+                            paramTypeUsageCount: curParamNode !== undefined ? 1 : 0,
+                            paramTypeWithEllipsisUsageCount: isParamTypeWithEllipsisUsage ? 1 : 0,
+                            returnTypeUsageCount: curParamNode === undefined ? 1 : 0,
+                            paramWithEllipsis: isParamTypeWithEllipsisUsage ? (_b = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.name) === null || _b === void 0 ? void 0 : _b.value : undefined,
+                            isExempt,
+                        });
+                    }
+                    else {
+                        existingEntry.nodes.push(nameNode);
+                        if (curParamNode !== undefined) {
+                            existingEntry.paramTypeUsageCount += 1;
+                            if (isParamTypeWithEllipsisUsage) {
+                                existingEntry.paramTypeWithEllipsisUsageCount += 1;
+                                if (!existingEntry.paramWithEllipsis) {
+                                    existingEntry.paramWithEllipsis = (_c = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.name) === null || _c === void 0 ? void 0 : _c.value;
+                                }
+                            }
+                        }
+                        else {
+                            existingEntry.returnTypeUsageCount += 1;
+                        }
+                    }
+                }
+                // Does this name refer to a TypeVar that is scoped to the class associated with
+                // this constructor method?
+                if (constructorClass && nameType.scopeId === constructorClass.details.typeVarScopeId) {
+                    const existingEntry = classTypeVarUsage.get(nameType.details.name);
+                    const isParamTypeWithEllipsisUsage = ((_d = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _d === void 0 ? void 0 : _d.nodeType) === 18 /* Ellipsis */;
+                    if (!existingEntry) {
+                        classTypeVarUsage.set(nameType.details.name, {
+                            nodes: [nameNode],
+                            paramTypeUsageCount: curParamNode !== undefined ? 1 : 0,
+                            paramTypeWithEllipsisUsageCount: isParamTypeWithEllipsisUsage ? 1 : 0,
+                            returnTypeUsageCount: 0,
+                            paramWithEllipsis: isParamTypeWithEllipsisUsage ? (_e = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.name) === null || _e === void 0 ? void 0 : _e.value : undefined,
+                            isExempt: false,
+                        });
+                    }
+                    else {
+                        existingEntry.nodes.push(nameNode);
+                        if (curParamNode !== undefined) {
+                            existingEntry.paramTypeUsageCount += 1;
+                            if (isParamTypeWithEllipsisUsage) {
+                                existingEntry.paramTypeWithEllipsisUsageCount += 1;
+                                if (!existingEntry.paramWithEllipsis) {
+                                    existingEntry.paramWithEllipsis = (_f = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.name) === null || _f === void 0 ? void 0 : _f.value;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        // Find all of the local type variables in signature.
+        node.parameters.forEach((param) => {
+            const annotation = param.typeAnnotation || param.typeAnnotationComment;
+            if (annotation) {
+                curParamNode = param;
+                nameWalker.walk(annotation);
+            }
+        });
+        curParamNode = undefined;
+        if (node.returnTypeAnnotation) {
+            // Don't exempt the use of a bound TypeVar when used as a type argument
+            // within a return type. This exemption applies only to input parameter
+            // annotations.
+            exemptBoundTypeVar = false;
+            nameWalker.walk(node.returnTypeAnnotation);
+        }
+        localTypeVarUsage.forEach((usage) => {
+            var _a;
+            // Report error for local type variable that appears only once.
+            if (usage.nodes.length === 1 && !usage.isExempt) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse, diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.Localizer.Diagnostic.typeVarUsedOnlyOnce().format({
+                    name: usage.nodes[0].value,
+                }), usage.nodes[0]);
+            }
+            // Report error for local type variable that appears in return type
+            // (but not as a top-level TypeVar within a union) and appears only
+            // within parameters that have default values. These may go unsolved.
+            let isUsedInReturnType = usage.returnTypeUsageCount > 0;
+            if (usage.returnTypeUsageCount === 1 && type.details.declaredReturnType) {
+                // If the TypeVar appears only once in the return type and it's a top-level
+                // TypeVar within a union, exempt it from this check. Although these
+                // TypeVars may go unsolved, they can be safely eliminated from the union
+                // without generating an Unknown type.
+                const returnType = type.details.declaredReturnType;
+                if ((0, types_1.isUnion)(returnType) &&
+                    returnType.subtypes.some((subtype) => (0, types_1.isTypeVar)(subtype) && subtype.details.name === usage.nodes[0].value)) {
+                    isUsedInReturnType = false;
+                }
+            }
+            if (isUsedInReturnType &&
+                usage.paramTypeWithEllipsisUsageCount > 0 &&
+                usage.paramTypeUsageCount === usage.paramTypeWithEllipsisUsageCount) {
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarUnsolvableRemedy());
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse, diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.Localizer.Diagnostic.typeVarPossiblyUnsolvable().format({
+                    name: usage.nodes[0].value,
+                    param: (_a = usage.paramWithEllipsis) !== null && _a !== void 0 ? _a : '',
+                }) + diag.getString(), usage.nodes[0]);
+            }
+        });
+        // Report error for a class type variable that appears only within
+        // constructor parameters that have default values. These may go unsolved.
+        classTypeVarUsage.forEach((usage) => {
+            var _a;
+            if (usage.paramTypeWithEllipsisUsageCount > 0 &&
+                usage.paramTypeUsageCount === usage.paramTypeWithEllipsisUsageCount) {
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarUnsolvableRemedy());
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse, diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.Localizer.Diagnostic.typeVarPossiblyUnsolvable().format({
+                    name: usage.nodes[0].value,
+                    param: (_a = usage.paramWithEllipsis) !== null && _a !== void 0 ? _a : '',
+                }) + diag.getString(), usage.nodes[0]);
+            }
+        });
+    }
+    _validateOverloadConsistency(node, functionType, prevOverloads) {
+        for (let i = 0; i < prevOverloads.length; i++) {
+            const prevOverload = prevOverloads[i];
+            if (types_1.FunctionType.isOverloaded(functionType) &&
+                types_1.FunctionType.isOverloaded(prevOverload) &&
+                this._isOverlappingOverload(functionType, prevOverload)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportOverlappingOverload, diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.Localizer.Diagnostic.overlappingOverload().format({
+                    name: node.name.value,
+                    obscured: prevOverloads.length + 1,
+                    obscuredBy: i + 1,
+                }), node.name);
+                break;
+            }
+        }
+        for (let i = 0; i < prevOverloads.length; i++) {
+            const prevOverload = prevOverloads[i];
+            if (types_1.FunctionType.isOverloaded(functionType) &&
+                types_1.FunctionType.isOverloaded(prevOverload) &&
+                this._isOverlappingOverload(prevOverload, functionType)) {
+                const prevReturnType = types_1.FunctionType.getSpecializedReturnType(prevOverload);
+                const returnType = types_1.FunctionType.getSpecializedReturnType(functionType);
+                if (prevReturnType &&
+                    returnType &&
+                    !this._evaluator.assignType(returnType, prevReturnType, 
+                    /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
+                    /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */ | 512 /* IgnoreTypeVarScope */)) {
+                    const altNode = this._findNodeForOverload(node, prevOverload);
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportOverlappingOverload, diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.Localizer.Diagnostic.overloadReturnTypeMismatch().format({
+                        name: node.name.value,
+                        newIndex: prevOverloads.length + 1,
+                        prevIndex: i + 1,
+                    }), (altNode || node).name);
+                    break;
+                }
+            }
+        }
+    }
+    // Mypy reports overlapping overload errors on the line that contains the
+    // earlier overload. Typeshed stubs contain type: ignore comments on these
+    // lines, so it is important for us to report them in the same manner.
+    _findNodeForOverload(functionNode, overloadType) {
+        const decls = this._evaluator.getDeclarationsForNameNode(functionNode.name);
+        if (!decls) {
+            return undefined;
+        }
+        for (const decl of decls) {
+            if (decl.type === 3 /* Function */) {
+                const functionType = this._evaluator.getTypeOfFunction(decl.node);
+                if ((functionType === null || functionType === void 0 ? void 0 : functionType.functionType) === overloadType) {
+                    return decl.node;
+                }
+            }
+        }
+        return undefined;
+    }
+    _isOverlappingOverload(functionType, prevOverload) {
+        // According to precedent, the __get__ method is special-cased and is
+        // exempt from overlapping overload checks. It's not clear why this is
+        // the case, but for consistency with other type checkers, we'll honor
+        // this rule. See https://github.com/python/typing/issues/253#issuecomment-389262904
+        // for details.
+        if (types_1.FunctionType.isInstanceMethod(functionType) && functionType.details.name === '__get__') {
+            return false;
+        }
+        return this._evaluator.assignType(functionType, prevOverload, 
+        /* diag */ undefined, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType)), 
+        /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */ |
+            32 /* SkipFunctionReturnTypeCheck */ |
+            16 /* OverloadOverlapCheck */);
+    }
+    _isLegalOverloadImplementation(overload, implementation, diag) {
+        var _a;
+        const implTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(implementation));
+        const overloadTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
+        // First check the parameters to see if they are assignable.
+        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 32 /* SkipFunctionReturnTypeCheck */ |
+            2 /* ReverseTypeVarMatching */ |
+            256 /* SkipSelfClsTypeCheck */);
+        // Now check the return types.
+        const overloadReturnType = (_a = overload.details.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
+        const implementationReturnType = (0, typeUtils_1.applySolvedTypeVars)(implementation.details.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implTypeVarContext);
+        const returnDiag = new diagnostic_1.DiagnosticAddendum();
+        if (!(0, types_1.isNever)(overloadReturnType) &&
+            !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implTypeVarContext, overloadTypeVarContext, 8 /* SkipSolveTypeVars */)) {
+            returnDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.functionReturnTypeMismatch().format({
+                sourceType: this._evaluator.printType(overloadReturnType, /* expandTypeAlias */ false),
+                destType: this._evaluator.printType(implementationReturnType, /* expandTypeAlias */ false),
+            }));
+            diag === null || diag === void 0 ? void 0 : diag.addAddendum(returnDiag);
+            isLegal = false;
+        }
+        return isLegal;
+    }
+    _walkStatementsAndReportUnreachable(statements) {
+        let reportedUnreachable = false;
+        let prevStatement;
+        for (const statement of statements) {
+            // No need to report unreachable more than once since the first time
+            // covers all remaining statements in the statement list.
+            if (!reportedUnreachable) {
+                if (!this._evaluator.isNodeReachable(statement, prevStatement)) {
+                    // Create a text range that covers the next statement through
+                    // the end of the statement list.
+                    const start = statement.start;
+                    const lastStatement = statements[statements.length - 1];
+                    const end = textRange_1.TextRange.getEnd(lastStatement);
+                    this._evaluator.addUnusedCode(statement, { start, length: end - start });
+                    reportedUnreachable = true;
+                }
+            }
+            if (!reportedUnreachable && this._fileInfo.isStubFile) {
+                this._validateStubStatement(statement);
+            }
+            this.walk(statement);
+            prevStatement = statement;
+        }
+    }
+    _validateStubStatement(statement) {
+        switch (statement.nodeType) {
+            case 19 /* If */:
+            case 28 /* Function */:
+            case 10 /* Class */:
+            case 0 /* Error */: {
+                // These are allowed in a stub file.
+                break;
+            }
+            case 57 /* While */:
+            case 26 /* For */:
+            case 53 /* Try */:
+            case 58 /* With */: {
+                // These are not allowed.
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidStubStatement, diagnosticRules_1.DiagnosticRule.reportInvalidStubStatement, localize_1.Localizer.Diagnostic.invalidStubStatement(), statement);
+                break;
+            }
+            case 47 /* StatementList */: {
+                for (const substatement of statement.statements) {
+                    let isValid = true;
+                    switch (substatement.nodeType) {
+                        case 2 /* Assert */:
+                        case 4 /* AssignmentExpression */:
+                        case 6 /* Await */:
+                        case 7 /* BinaryOperation */:
+                        case 11 /* Constant */:
+                        case 14 /* Del */:
+                        case 15 /* Dictionary */:
+                        case 24 /* Index */:
+                        case 26 /* For */:
+                        case 27 /* FormatString */:
+                        case 29 /* Global */:
+                        case 30 /* Lambda */:
+                        case 31 /* List */:
+                        case 35 /* MemberAccess */:
+                        case 38 /* Name */:
+                        case 39 /* Nonlocal */:
+                        case 40 /* Number */:
+                        case 43 /* Raise */:
+                        case 44 /* Return */:
+                        case 45 /* Set */:
+                        case 46 /* Slice */:
+                        case 51 /* Ternary */:
+                        case 52 /* Tuple */:
+                        case 53 /* Try */:
+                        case 55 /* UnaryOperation */:
+                        case 56 /* Unpack */:
+                        case 57 /* While */:
+                        case 58 /* With */:
+                        case 59 /* WithItem */:
+                        case 60 /* Yield */:
+                        case 61 /* YieldFrom */: {
+                            isValid = false;
+                            break;
+                        }
+                        case 5 /* AugmentedAssignment */: {
+                            // Exempt __all__ manipulations.
+                            isValid =
+                                substatement.operator === 1 /* AddEqual */ &&
+                                    substatement.leftExpression.nodeType === 38 /* Name */ &&
+                                    substatement.leftExpression.value === '__all__';
+                            break;
+                        }
+                        case 9 /* Call */: {
+                            // Exempt __all__ manipulations.
+                            isValid =
+                                substatement.leftExpression.nodeType === 35 /* MemberAccess */ &&
+                                    substatement.leftExpression.leftExpression.nodeType === 38 /* Name */ &&
+                                    substatement.leftExpression.leftExpression.value === '__all__';
+                            break;
+                        }
+                    }
+                    if (!isValid) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidStubStatement, diagnosticRules_1.DiagnosticRule.reportInvalidStubStatement, localize_1.Localizer.Diagnostic.invalidStubStatement(), substatement);
+                    }
+                }
+            }
+        }
+    }
+    _validateExceptionType(exceptionType, errorNode) {
+        const baseExceptionType = this._evaluator.getBuiltInType(errorNode, 'BaseException');
+        const derivesFromBaseException = (classType) => {
+            if (!baseExceptionType || !(0, types_1.isInstantiableClass)(baseExceptionType)) {
+                return true;
+            }
+            return (0, typeUtils_1.derivesFromClassRecursive)(classType, baseExceptionType, /* ignoreUnknown */ false);
+        };
+        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        let resultingExceptionType;
+        if ((0, types_1.isAnyOrUnknown)(exceptionType)) {
+            resultingExceptionType = exceptionType;
+        }
+        else {
+            if ((0, types_1.isInstantiableClass)(exceptionType)) {
+                if (!derivesFromBaseException(exceptionType)) {
+                    diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                        type: this._evaluator.printType(exceptionType, /* expandTypeAlias */ false),
+                    }));
+                }
+                resultingExceptionType = types_1.ClassType.cloneAsInstance(exceptionType);
+            }
+            else if ((0, types_1.isClassInstance)(exceptionType)) {
+                const iterableType = this._evaluator.getTypeOfIterator(exceptionType, /* isAsync */ false, errorNode) ||
+                    types_1.UnknownType.create();
+                resultingExceptionType = (0, typeUtils_1.mapSubtypes)(iterableType, (subtype) => {
+                    if ((0, types_1.isAnyOrUnknown)(subtype)) {
+                        return subtype;
+                    }
+                    if ((0, types_1.isInstantiableClass)(subtype)) {
+                        if (!derivesFromBaseException(subtype)) {
+                            diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                                type: this._evaluator.printType(exceptionType, /* expandTypeAlias */ false),
+                            }));
+                        }
+                        return types_1.ClassType.cloneAsInstance(subtype);
+                    }
+                    diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
+                        type: this._evaluator.printType(exceptionType, /* expandTypeAlias */ false),
+                    }));
+                    return types_1.UnknownType.create();
+                });
+            }
+        }
+        if (!diagAddendum.isEmpty()) {
+            this._evaluator.addError(localize_1.Localizer.Diagnostic.exceptionTypeNotClass().format({
+                type: this._evaluator.printType(exceptionType, /* expandTypeAlias */ false),
+            }), errorNode);
+        }
+        return resultingExceptionType || types_1.UnknownType.create();
+    }
+    _reportUnusedDunderAllSymbols(nodes) {
+        // If this rule is disabled, don't bother doing the work.
+        if (this._fileInfo.diagnosticRuleSet.reportUnsupportedDunderAll === 'none') {
+            return;
+        }
+        const moduleScope = AnalyzerNodeInfo.getScope(this._moduleNode);
+        if (!moduleScope) {
+            return;
+        }
+        nodes.forEach((node) => {
+            if (!moduleScope.symbolTable.has(node.value)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnsupportedDunderAll, diagnosticRules_1.DiagnosticRule.reportUnsupportedDunderAll, localize_1.Localizer.Diagnostic.dunderAllSymbolNotPresent().format({ name: node.value }), node);
+            }
+        });
+    }
+    _validateSymbolTables() {
+        for (const scopedNode of this._scopedNodes) {
+            const scope = AnalyzerNodeInfo.getScope(scopedNode);
+            if (scope) {
+                scope.symbolTable.forEach((symbol, name) => {
+                    this._conditionallyReportUnusedSymbol(name, symbol, scope.type);
+                    this._reportIncompatibleDeclarations(name, symbol);
+                    this._reportMultipleFinalDeclarations(name, symbol, scope.type);
+                    this._reportMultipleTypeAliasDeclarations(name, symbol);
+                    this._reportInvalidOverload(name, symbol);
+                });
+            }
+        }
+    }
+    _reportInvalidOverload(name, symbol) {
+        const typedDecls = symbol.getTypedDeclarations();
+        if (typedDecls.length >= 1) {
+            const primaryDecl = typedDecls[0];
+            if (primaryDecl.type === 3 /* Function */) {
+                const type = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+                const functions = (0, types_1.isOverloadedFunction)(type) ? type.overloads : (0, types_1.isFunction)(type) ? [type] : [];
+                const overloadedFunctions = functions.filter((func) => types_1.FunctionType.isOverloaded(func));
+                if (overloadedFunctions.length === 1) {
+                    // There should never be a single overload.
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.singleOverload().format({ name }), primaryDecl.node.name);
+                }
+                overloadedFunctions.forEach((overload) => {
+                    if (overload.details.declaration &&
+                        !ParseTreeUtils.isFunctionSuiteEmpty(overload.details.declaration.node)) {
+                        const diag = new diagnostic_1.DiagnosticAddendum();
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overloadWithImplementation());
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadWithImplementation().format({ name }) + diag.getString(), overload.details.declaration.node.name);
+                    }
+                });
+                // If the file is not a stub and this is the first overload,
+                // verify that there is an implementation.
+                if (!this._fileInfo.isStubFile && overloadedFunctions.length > 0) {
+                    let implementationFunction;
+                    if ((0, types_1.isOverloadedFunction)(type) &&
+                        !types_1.FunctionType.isOverloaded(type.overloads[type.overloads.length - 1])) {
+                        implementationFunction = type.overloads[type.overloads.length - 1];
+                    }
+                    else if ((0, types_1.isFunction)(type) && !types_1.FunctionType.isOverloaded(type)) {
+                        implementationFunction = type;
+                    }
+                    if (!implementationFunction) {
+                        let isProtocolMethod = false;
+                        const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(primaryDecl.node);
+                        if (containingClassNode && containingClassNode.nodeType === 10 /* Class */) {
+                            const classType = this._evaluator.getTypeOfClass(containingClassNode);
+                            if (classType && types_1.ClassType.isProtocolClass(classType.classType)) {
+                                isProtocolMethod = true;
+                            }
+                        }
+                        // If this is a method within a protocol class, don't require that
+                        // there is an implementation.
+                        if (!isProtocolMethod) {
+                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadWithoutImplementation().format({
+                                name: primaryDecl.node.name.value,
+                            }), primaryDecl.node.name);
+                        }
+                    }
+                    else if ((0, types_1.isOverloadedFunction)(type)) {
+                        // Verify that all overload signatures are assignable to implementation signature.
+                        type.overloads.forEach((overload, index) => {
+                            var _a, _b, _c, _d;
+                            if (overload === implementationFunction || !types_1.FunctionType.isOverloaded(overload)) {
+                                return;
+                            }
+                            const diag = new diagnostic_1.DiagnosticAddendum();
+                            if (!this._isLegalOverloadImplementation(overload, implementationFunction, diag)) {
+                                if (implementationFunction.details.declaration) {
+                                    const diagnostic = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadImplementationMismatch().format({
+                                        name,
+                                        index: index + 1,
+                                    }) + diag.getString(), implementationFunction.details.declaration.node.name);
+                                    if (diagnostic && overload.details.declaration) {
+                                        diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overloadSignature(), (_b = (_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : primaryDecl.path, (_d = (_c = overload.details.declaration) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : primaryDecl.range);
+                                    }
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+        }
+    }
+    _reportMultipleFinalDeclarations(name, symbol, scopeType) {
+        if (!(0, symbolUtils_1.isFinalVariable)(symbol)) {
+            return;
+        }
+        const decls = symbol.getDeclarations();
+        let sawFinal = false;
+        let sawAssignment = false;
+        decls.forEach((decl) => {
+            if ((0, declarationUtils_1.isFinalVariableDeclaration)(decl)) {
+                if (sawFinal) {
+                    this._evaluator.addError(localize_1.Localizer.Diagnostic.finalRedeclaration().format({ name }), decl.node);
+                }
+                sawFinal = true;
+            }
+            if (decl.type === 1 /* Variable */ && decl.inferredTypeSource) {
+                if (sawAssignment) {
+                    // We check for assignment of Final instance and class variables
+                    // the type evaluator because we need to take into account whether
+                    // the assignment is within an `__init__` method, so ignore class
+                    // scopes here.
+                    if (scopeType !== 2 /* Class */) {
+                        this._evaluator.addError(localize_1.Localizer.Diagnostic.finalReassigned().format({ name }), decl.node);
+                    }
+                }
+                sawAssignment = true;
+            }
+        });
+        // If it's not a stub file, an assignment must be provided.
+        if (!sawAssignment && !this._fileInfo.isStubFile) {
+            const firstDecl = decls.find((decl) => decl.type === 1 /* Variable */ && decl.isFinal);
+            if (firstDecl) {
+                // Is this an instance variable declared within a dataclass? If so, it
+                // is implicitly initialized by the synthesized `__init__` method and
+                // therefore has an implied assignment.
+                let isImplicitlyAssigned = false;
+                if (symbol.isClassMember() && !symbol.isClassVar()) {
+                    const containingClass = ParseTreeUtils.getEnclosingClass(firstDecl.node, /* stopAtFunction */ true);
+                    if (containingClass) {
+                        const classType = this._evaluator.getTypeOfClass(containingClass);
+                        if (classType &&
+                            (0, types_1.isClass)(classType.decoratedType) &&
+                            types_1.ClassType.isDataClass(classType.decoratedType)) {
+                            isImplicitlyAssigned = true;
+                        }
+                    }
+                }
+                if (!isImplicitlyAssigned) {
+                    this._evaluator.addError(localize_1.Localizer.Diagnostic.finalUnassigned().format({ name }), firstDecl.node);
+                }
+            }
+        }
+    }
+    _reportMultipleTypeAliasDeclarations(name, symbol) {
+        const decls = symbol.getDeclarations();
+        const typeAliasDecl = decls.find((decl) => (0, declarationUtils_1.isExplicitTypeAliasDeclaration)(decl));
+        // If this is a type alias, there should be only one declaration.
+        if (typeAliasDecl && decls.length > 1) {
+            decls.forEach((decl) => {
+                if (decl !== typeAliasDecl) {
+                    this._evaluator.addError(localize_1.Localizer.Diagnostic.typeAliasRedeclared().format({ name }), decl.node);
+                }
+            });
+        }
+    }
+    _reportIncompatibleDeclarations(name, symbol) {
+        // If there's one or more declaration with a declared type,
+        // all other declarations should match. The only exception is
+        // for functions that have an overload.
+        const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+        // If there's no declaration with a declared type, we're done.
+        if (!primaryDecl) {
+            return;
+        }
+        // Special case the '_' symbol, which is used in single dispatch
+        // code and other cases where the name does not matter.
+        if (name === '_') {
+            return;
+        }
+        let otherDecls = symbol.getDeclarations().filter((decl) => decl !== primaryDecl);
+        // If it's a function, we can skip any other declarations
+        // that are overloads or property setters/deleters.
+        if (primaryDecl.type === 3 /* Function */) {
+            const primaryDeclTypeInfo = this._evaluator.getTypeOfFunction(primaryDecl.node);
+            otherDecls = otherDecls.filter((decl) => {
+                if (decl.type !== 3 /* Function */) {
+                    return true;
+                }
+                const funcTypeInfo = this._evaluator.getTypeOfFunction(decl.node);
+                if (!funcTypeInfo) {
+                    return true;
+                }
+                const decoratedType = primaryDeclTypeInfo
+                    ? this._evaluator.makeTopLevelTypeVarsConcrete(primaryDeclTypeInfo.decoratedType)
+                    : undefined;
+                // We need to handle properties in a careful manner because of
+                // the way that setters and deleters are often defined using multiple
+                // methods with the same name.
+                if (decoratedType &&
+                    (0, types_1.isClassInstance)(decoratedType) &&
+                    types_1.ClassType.isPropertyClass(decoratedType) &&
+                    (0, types_1.isClassInstance)(funcTypeInfo.decoratedType) &&
+                    types_1.ClassType.isPropertyClass(funcTypeInfo.decoratedType)) {
+                    return funcTypeInfo.decoratedType.details.typeSourceId !== decoratedType.details.typeSourceId;
+                }
+                return !types_1.FunctionType.isOverloaded(funcTypeInfo.functionType);
+            });
+        }
+        // If there are no other declarations to consider, we're done.
+        if (otherDecls.length === 0) {
+            return;
+        }
+        let primaryDeclInfo;
+        if (primaryDecl.type === 3 /* Function */) {
+            if (primaryDecl.isMethod) {
+                primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeMethodDeclaration();
+            }
+            else {
+                primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeFunctionDeclaration();
+            }
+        }
+        else if (primaryDecl.type === 4 /* Class */) {
+            primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeClassDeclaration();
+        }
+        else if (primaryDecl.type === 2 /* Parameter */) {
+            primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeParameterDeclaration();
+        }
+        else if (primaryDecl.type === 1 /* Variable */) {
+            primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeVariableDeclaration();
+        }
+        else {
+            primaryDeclInfo = localize_1.Localizer.DiagnosticAddendum.seeDeclaration();
+        }
+        const addPrimaryDeclInfo = (diag) => {
+            if (diag) {
+                let primaryDeclNode;
+                if (primaryDecl.type === 3 /* Function */ || primaryDecl.type === 4 /* Class */) {
+                    primaryDeclNode = primaryDecl.node.name;
+                }
+                else if (primaryDecl.type === 1 /* Variable */) {
+                    if (primaryDecl.node.nodeType === 38 /* Name */) {
+                        primaryDeclNode = primaryDecl.node;
+                    }
+                }
+                else if (primaryDecl.type === 2 /* Parameter */) {
+                    if (primaryDecl.node.name) {
+                        primaryDeclNode = primaryDecl.node.name;
+                    }
+                }
+                if (primaryDeclNode) {
+                    diag.addRelatedInfo(primaryDeclInfo, primaryDecl.path, primaryDecl.range);
+                }
+            }
+        };
+        for (const otherDecl of otherDecls) {
+            if (otherDecl.type === 4 /* Class */) {
+                const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredClassDeclaration().format({ name }), otherDecl.node.name);
+                addPrimaryDeclInfo(diag);
+            }
+            else if (otherDecl.type === 3 /* Function */) {
+                const primaryType = this._evaluator.getTypeForDeclaration(primaryDecl);
+                // If the return type has not yet been inferred, do so now.
+                if (primaryType && (0, types_1.isFunction)(primaryType)) {
+                    this._evaluator.getFunctionInferredReturnType(primaryType);
+                }
+                let duplicateIsOk = false;
+                const otherType = this._evaluator.getTypeForDeclaration(otherDecl);
+                const suite1 = ParseTreeUtils.getEnclosingSuite(primaryDecl.node);
+                const suite2 = ParseTreeUtils.getEnclosingSuite(otherDecl.node);
+                const isInSameStatementList = suite1 === suite2;
+                // If the return type has not yet been inferred, do so now.
+                if (otherType && (0, types_1.isFunction)(otherType)) {
+                    this._evaluator.getFunctionInferredReturnType(otherType);
+                }
+                // If both declarations are functions, it's OK if they
+                // both have the same signatures.
+                if (primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
+                    duplicateIsOk = true;
+                }
+                if (!duplicateIsOk || isInSameStatementList) {
+                    const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, otherDecl.isMethod
+                        ? localize_1.Localizer.Diagnostic.obscuredMethodDeclaration().format({ name })
+                        : localize_1.Localizer.Diagnostic.obscuredFunctionDeclaration().format({ name }), otherDecl.node.name);
+                    addPrimaryDeclInfo(diag);
+                }
+            }
+            else if (otherDecl.type === 2 /* Parameter */) {
+                if (otherDecl.node.name) {
+                    const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredParameterDeclaration().format({ name }), otherDecl.node.name);
+                    addPrimaryDeclInfo(diag);
+                }
+            }
+            else if (otherDecl.type === 1 /* Variable */) {
+                const primaryType = this._evaluator.getTypeForDeclaration(primaryDecl);
+                if (otherDecl.typeAnnotationNode) {
+                    if (otherDecl.node.nodeType === 38 /* Name */) {
+                        let duplicateIsOk = false;
+                        // It's OK if they both have the same declared type.
+                        const otherType = this._evaluator.getTypeForDeclaration(otherDecl);
+                        if (primaryType && otherType && (0, types_1.isTypeSame)(primaryType, otherType)) {
+                            duplicateIsOk = true;
+                        }
+                        if (!duplicateIsOk) {
+                            const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredVariableDeclaration().format({ name }), otherDecl.node);
+                            addPrimaryDeclInfo(diag);
+                        }
+                    }
+                }
+                else if (primaryType && !(0, typeUtils_1.isProperty)(primaryType)) {
+                    if (primaryDecl.type === 3 /* Function */ || primaryDecl.type === 4 /* Class */) {
+                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.obscuredVariableDeclaration().format({ name }), otherDecl.node);
+                        addPrimaryDeclInfo(diag);
+                    }
+                }
+            }
+        }
+    }
+    _conditionallyReportUnusedSymbol(name, symbol, scopeType) {
+        const accessedSymbolMap = this._fileInfo.accessedSymbolMap;
+        if (symbol.isIgnoredForProtocolMatch() || accessedSymbolMap.has(symbol.id)) {
+            return;
+        }
+        // A name of "_" means "I know this symbol isn't used", so
+        // don't report it as unused.
+        if (name === '_') {
+            return;
+        }
+        if (SymbolNameUtils.isDunderName(name)) {
+            return;
+        }
+        const decls = symbol.getDeclarations();
+        decls.forEach((decl) => {
+            this._conditionallyReportUnusedDeclaration(decl, this._isSymbolPrivate(name, scopeType));
+        });
+    }
+    _conditionallyReportUnusedDeclaration(decl, isPrivate) {
+        let diagnosticLevel;
+        let nameNode;
+        let message;
+        let rule;
+        switch (decl.type) {
+            case 6 /* Alias */:
+                diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedImport;
+                rule = diagnosticRules_1.DiagnosticRule.reportUnusedImport;
+                if (decl.node.nodeType === 21 /* ImportAs */) {
+                    if (decl.node.alias) {
+                        // Aliases in stub files are assumed to be re-exports.
+                        if (!this._fileInfo.isStubFile) {
+                            nameNode = decl.node.alias;
+                        }
+                    }
+                    else {
+                        // Handle multi-part names specially.
+                        const nameParts = decl.node.module.nameParts;
+                        if (nameParts.length > 0) {
+                            const multipartName = nameParts.map((np) => np.value).join('.');
+                            const textRange = { start: nameParts[0].start, length: nameParts[0].length };
+                            textRange_1.TextRange.extend(textRange, nameParts[nameParts.length - 1]);
+                            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unaccessedSymbol().format({ name: multipartName }), textRange, { action: "pyright.unusedImport" /* unusedImport */ });
+                            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportUnusedImport, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.Localizer.Diagnostic.unaccessedImport().format({ name: multipartName }), textRange);
+                            return;
+                        }
+                    }
+                }
+                else if (decl.node.nodeType === 23 /* ImportFromAs */) {
+                    const importFrom = decl.node.parent;
+                    // If this is a stub file that is using the "from A import B as C" or "from . import C",
+                    // don't mark "C" as unaccessed because it's assumed to be re-exported.
+                    const isReexport = this._fileInfo.isStubFile && decl.node.alias !== undefined;
+                    // If this is a __future__ import, it's OK for the import symbol to be unaccessed.
+                    const isFuture = importFrom.module.nameParts.length === 1 &&
+                        importFrom.module.nameParts[0].value === '__future__';
+                    if (!isReexport && !isFuture) {
+                        nameNode = decl.node.alias || decl.node.name;
+                    }
+                }
+                if (nameNode) {
+                    message = localize_1.Localizer.Diagnostic.unaccessedImport().format({ name: nameNode.value });
+                }
+                break;
+            case 1 /* Variable */:
+            case 2 /* Parameter */:
+                if (!isPrivate) {
+                    return;
+                }
+                if (this._fileInfo.isStubFile) {
+                    // Don't mark variables or parameters as unaccessed in
+                    // stub files. It's typical for them to be unaccessed here.
+                    return;
+                }
+                diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedVariable;
+                if (decl.node.nodeType === 38 /* Name */) {
+                    nameNode = decl.node;
+                    // Don't emit a diagnostic if the name starts with an underscore.
+                    // This indicates that the variable is unused.
+                    if (nameNode.value.startsWith('_')) {
+                        diagnosticLevel = 'none';
+                    }
+                }
+                else if (decl.node.nodeType === 41 /* Parameter */) {
+                    nameNode = decl.node.name;
+                    // Don't emit a diagnostic for unused parameters.
+                    diagnosticLevel = 'none';
+                }
+                if (nameNode) {
+                    rule = diagnosticRules_1.DiagnosticRule.reportUnusedVariable;
+                    message = localize_1.Localizer.Diagnostic.unaccessedVariable().format({ name: nameNode.value });
+                }
+                break;
+            case 4 /* Class */:
+                if (!isPrivate) {
+                    return;
+                }
+                // If a stub is exporting a private type, we'll assume that the author
+                // knows what he or she is doing.
+                if (this._fileInfo.isStubFile) {
+                    return;
+                }
+                diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedClass;
+                nameNode = decl.node.name;
+                rule = diagnosticRules_1.DiagnosticRule.reportUnusedClass;
+                message = localize_1.Localizer.Diagnostic.unaccessedClass().format({ name: nameNode.value });
+                break;
+            case 3 /* Function */:
+                if (!isPrivate) {
+                    return;
+                }
+                // If a stub is exporting a private type, we'll assume that the author
+                // knows what he or she is doing.
+                if (this._fileInfo.isStubFile) {
+                    return;
+                }
+                diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedFunction;
+                nameNode = decl.node.name;
+                rule = diagnosticRules_1.DiagnosticRule.reportUnusedFunction;
+                message = localize_1.Localizer.Diagnostic.unaccessedFunction().format({ name: nameNode.value });
+                break;
+            default:
+                return;
+        }
+        if (nameNode && rule !== undefined && message) {
+            const action = rule === diagnosticRules_1.DiagnosticRule.reportUnusedImport ? { action: "pyright.unusedImport" /* unusedImport */ } : undefined;
+            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unaccessedSymbol().format({ name: nameNode.value }), nameNode, action);
+            this._evaluator.addDiagnostic(diagnosticLevel, rule, message, nameNode);
+        }
+    }
+    // Validates that a call to isinstance or issubclass are necessary. This is a
+    // common source of programming errors. Also validates that arguments passed
+    // to isinstance or issubclass won't generate exceptions.
+    _validateIsInstanceCall(node) {
+        if (node.leftExpression.nodeType !== 38 /* Name */ ||
+            (node.leftExpression.value !== 'isinstance' && node.leftExpression.value !== 'issubclass') ||
+            node.arguments.length !== 2) {
+            return;
+        }
+        const callName = node.leftExpression.value;
+        const isInstanceCheck = callName === 'isinstance';
+        let arg0Type = this._evaluator.getType(node.arguments[0].valueExpression);
+        if (!arg0Type) {
+            return;
+        }
+        arg0Type = (0, typeUtils_1.mapSubtypes)(arg0Type, (subtype) => {
+            return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
+        });
+        const arg1Type = this._evaluator.getType(node.arguments[1].valueExpression);
+        if (!arg1Type) {
+            return;
+        }
+        let isValidType = true;
+        (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
+            if ((0, types_1.isClassInstance)(arg1Subtype) && types_1.ClassType.isTupleClass(arg1Subtype) && arg1Subtype.tupleTypeArguments) {
+                if (arg1Subtype.tupleTypeArguments.some((typeArg) => !this._isTypeSupportedTypeForIsInstance(typeArg.type, isInstanceCheck))) {
+                    isValidType = false;
+                }
+            }
+            else {
+                if (!this._isTypeSupportedTypeForIsInstance(arg1Subtype, isInstanceCheck)) {
+                    isValidType = false;
+                }
+            }
+        });
+        if (!isValidType) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarNotAllowed());
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, isInstanceCheck
+                ? localize_1.Localizer.Diagnostic.isInstanceInvalidType().format({
+                    type: this._evaluator.printType(arg1Type, /* expandTypeAlias */ false),
+                }) + diag.getString()
+                : localize_1.Localizer.Diagnostic.isSubclassInvalidType().format({
+                    type: this._evaluator.printType(arg1Type, /* expandTypeAlias */ false),
+                }) + diag.getString(), node.arguments[1]);
+        }
+        // If this call is within an assert statement, we won't check whether
+        // it's unnecessary.
+        let curNode = node;
+        while (curNode) {
+            if (curNode.nodeType === 2 /* Assert */) {
+                return;
+            }
+            curNode = curNode.parent;
+        }
+        // Several built-in classes don't follow the normal class hierarchy
+        // rules, so we'll avoid emitting false-positive diagnostics if these
+        // are used.
+        const nonstandardClassTypes = [
+            'FunctionType',
+            'LambdaType',
+            'BuiltinFunctionType',
+            'BuiltinMethodType',
+            'type',
+            'Type',
+        ];
+        const classTypeList = [];
+        let arg1IncludesSubclasses = false;
+        (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
+            if ((0, types_1.isClass)(arg1Subtype)) {
+                if (types_1.TypeBase.isInstantiable(arg1Subtype)) {
+                    if (arg1Subtype.literalValue === undefined) {
+                        classTypeList.push(arg1Subtype);
+                        if (types_1.ClassType.isBuiltIn(arg1Subtype) &&
+                            nonstandardClassTypes.some((name) => name === arg1Subtype.details.name)) {
+                            isValidType = false;
+                        }
+                        if (arg1Subtype.includeSubclasses) {
+                            arg1IncludesSubclasses = true;
+                        }
+                    }
+                }
+                else {
+                    // The isinstance and issubclass call supports a variation where the second
+                    // parameter is a tuple of classes.
+                    if ((0, typeUtils_1.isTupleClass)(arg1Subtype)) {
+                        if (arg1Subtype.tupleTypeArguments) {
+                            arg1Subtype.tupleTypeArguments.forEach((typeArg) => {
+                                if ((0, types_1.isInstantiableClass)(typeArg.type)) {
+                                    classTypeList.push(typeArg.type);
+                                    if (typeArg.type.includeSubclasses) {
+                                        arg1IncludesSubclasses = true;
+                                    }
+                                }
+                                else {
+                                    isValidType = false;
+                                }
+                            });
+                        }
+                    }
+                    else {
+                        if (arg1Subtype.includeSubclasses) {
+                            arg1IncludesSubclasses = true;
+                        }
+                    }
+                    if (types_1.ClassType.isBuiltIn(arg1Subtype) &&
+                        nonstandardClassTypes.some((name) => name === arg1Subtype.details.name)) {
+                        isValidType = false;
+                    }
+                }
+            }
+            else {
+                isValidType = false;
+            }
+        });
+        if (!isValidType) {
+            return;
+        }
+        // According to PEP 544, protocol classes cannot be used as the right-hand
+        // argument to isinstance or issubclass unless they are annotated as
+        // "runtime checkable".
+        if (classTypeList.some((type) => types_1.ClassType.isProtocolClass(type) && !types_1.ClassType.isRuntimeCheckable(type))) {
+            this._evaluator.addError(localize_1.Localizer.Diagnostic.protocolUsedInCall().format({ name: callName }), node.arguments[1].valueExpression);
+        }
+        if ((0, typeUtils_1.derivesFromAnyOrUnknown)(arg0Type)) {
+            return;
+        }
+        const finalizeFilteredTypeList = (types) => {
+            return (0, types_1.combineTypes)(types);
+        };
+        const filterType = (varType) => {
+            const filteredTypes = [];
+            for (const filterType of classTypeList) {
+                // Handle the special case where the variable type is a TypedDict and
+                // we're filtering against 'dict'. TypedDict isn't derived from dict,
+                // but at runtime, isinstance returns True.
+                const filterIsSuperclass = types_1.ClassType.isDerivedFrom(varType, filterType) ||
+                    (isInstanceCheck &&
+                        types_1.ClassType.isProtocolClass(filterType) &&
+                        this._evaluator.assignType(filterType, varType)) ||
+                    (types_1.ClassType.isBuiltIn(filterType, 'dict') && types_1.ClassType.isTypedDictClass(varType));
+                const filterIsSubclass = types_1.ClassType.isDerivedFrom(filterType, varType) ||
+                    (isInstanceCheck &&
+                        types_1.ClassType.isProtocolClass(varType) &&
+                        this._evaluator.assignType(varType, filterType));
+                // Normally, a class should never be both a subclass and a
+                // superclass. However, this can happen if one of the classes
+                // derives from an unknown type. In this case, we'll add an
+                // unknown type into the filtered type list to avoid any
+                // false positives.
+                const isClassRelationshipIndeterminate = filterIsSubclass && filterIsSubclass && !types_1.ClassType.isSameGenericClass(varType, filterType);
+                if (isClassRelationshipIndeterminate) {
+                    filteredTypes.push(types_1.UnknownType.create());
+                }
+                else if (filterIsSuperclass) {
+                    // If the variable type is a subclass of the isinstance
+                    // filter, we haven't learned anything new about the
+                    // variable type.
+                    filteredTypes.push(varType);
+                }
+                else if (filterIsSubclass) {
+                    // If the variable type is a superclass of the isinstance
+                    // filter, we can narrow the type to the subclass.
+                    filteredTypes.push(filterType);
+                }
+            }
+            if (!isInstanceCheck) {
+                return filteredTypes;
+            }
+            // Make all instantiable classes into instances before returning them.
+            return filteredTypes.map((t) => ((0, types_1.isInstantiableClass)(t) ? types_1.ClassType.cloneAsInstance(t) : t));
+        };
+        let filteredType;
+        if (isInstanceCheck && (0, types_1.isClassInstance)(arg0Type)) {
+            const remainingTypes = filterType(types_1.ClassType.cloneAsInstantiable(arg0Type));
+            filteredType = finalizeFilteredTypeList(remainingTypes);
+        }
+        else if (!isInstanceCheck && (0, types_1.isInstantiableClass)(arg0Type)) {
+            const remainingTypes = filterType(arg0Type);
+            filteredType = finalizeFilteredTypeList(remainingTypes);
+        }
+        else if ((0, types_1.isUnion)(arg0Type)) {
+            let remainingTypes = [];
+            let foundAnyType = false;
+            (0, typeUtils_1.doForEachSubtype)(arg0Type, (subtype) => {
+                if ((0, types_1.isAnyOrUnknown)(subtype)) {
+                    foundAnyType = true;
+                }
+                if (isInstanceCheck && (0, types_1.isClassInstance)(subtype)) {
+                    remainingTypes = remainingTypes.concat(filterType(types_1.ClassType.cloneAsInstantiable(subtype)));
+                }
+                else if (!isInstanceCheck && (0, types_1.isInstantiableClass)(subtype)) {
+                    remainingTypes = remainingTypes.concat(filterType(subtype));
+                }
+            });
+            filteredType = finalizeFilteredTypeList(remainingTypes);
+            // If we found an any or unknown type, all bets are off.
+            if (foundAnyType) {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+        const getTestType = () => {
+            const objTypeList = classTypeList.map((t) => types_1.ClassType.cloneAsInstance(t));
+            return (0, types_1.combineTypes)(objTypeList);
+        };
+        // If arg1IncludesSubclasses is true, it contains a Type[X] class rather than X. A Type[X]
+        // could be a subclass of X, so the "unnecessary isinstance check" may be legit.
+        if (!arg1IncludesSubclasses && (0, types_1.isTypeSame)(filteredType, arg0Type, /* ignorePseudoGeneric */ true)) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryIsInstance, diagnosticRules_1.DiagnosticRule.reportUnnecessaryIsInstance, isInstanceCheck
+                ? localize_1.Localizer.Diagnostic.unnecessaryIsInstanceAlways().format({
+                    testType: this._evaluator.printType(arg0Type, /* expandTypeAlias */ false),
+                    classType: this._evaluator.printType(getTestType(), /* expandTypeAlias */ false),
+                })
+                : localize_1.Localizer.Diagnostic.unnecessaryIsSubclassAlways().format({
+                    testType: this._evaluator.printType(arg0Type, /* expandTypeAlias */ false),
+                    classType: this._evaluator.printType(getTestType(), /* expandTypeAlias */ false),
+                }), node);
+        }
+    }
+    // Determines whether the specified type is allowed as the second argument
+    // to an isinstance or issubclass check.
+    _isTypeSupportedTypeForIsInstance(type, isInstanceCheck) {
+        let isSupported = true;
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
+            switch (subtype.category) {
+                case 2 /* Any */:
+                case 1 /* Unknown */:
+                case 0 /* Unbound */:
+                    break;
+                case 7 /* Class */:
+                    // If it's a class, make sure that it has not been given explicit
+                    // type arguments. This will result in a TypeError exception.
+                    if (subtype.isTypeArgumentExplicit && !subtype.includeSubclasses) {
+                        isSupported = false;
+                    }
+                    break;
+                case 3 /* None */:
+                    if (!isInstanceCheck) {
+                        isSupported = false;
+                    }
+                    else {
+                        isSupported = types_1.TypeBase.isInstantiable(subtype);
+                    }
+                    break;
+                case 5 /* Function */:
+                    isSupported = types_1.TypeBase.isInstantiable(subtype);
+                    break;
+                case 9 /* Union */:
+                    isSupported = this._isTypeSupportedTypeForIsInstance(subtype, isInstanceCheck);
+                    break;
+                default:
+                    isSupported = false;
+                    break;
+            }
+        });
+        return isSupported;
+    }
+    _isSymbolPrivate(nameValue, scopeType) {
+        // All variables within the scope of a function or a list
+        // comprehension are considered private.
+        if (scopeType === 1 /* Function */ || scopeType === 0 /* ListComprehension */) {
+            return true;
+        }
+        // See if the symbol is private.
+        if (SymbolNameUtils.isPrivateName(nameValue)) {
+            return true;
+        }
+        if (SymbolNameUtils.isProtectedName(nameValue)) {
+            // Protected names outside of a class scope are considered private.
+            const isClassScope = scopeType === 2 /* Class */;
+            return !isClassScope;
+        }
+        return false;
+    }
+    _reportDeprecatedUse(node) {
+        var _a;
+        const deprecatedForm = (_a = deprecatedAliases.get(node.value)) !== null && _a !== void 0 ? _a : deprecatedSpecialForms.get(node.value);
+        if (!deprecatedForm) {
+            return;
+        }
+        const type = this._evaluator.getType(node);
+        if (!type) {
+            return;
+        }
+        if (!(0, types_1.isInstantiableClass)(type) || type.details.fullName !== deprecatedForm.fullName) {
+            return;
+        }
+        if (this._fileInfo.executionEnvironment.pythonVersion >= deprecatedForm.version) {
+            this._evaluator.addDeprecated(localize_1.Localizer.Diagnostic.deprecatedType().format({
+                version: (0, pythonVersion_1.versionToString)(deprecatedForm.version),
+                replacement: deprecatedForm.replacementText,
+            }), node);
+        }
+    }
+    _reportUnboundName(node) {
+        if (this._fileInfo.diagnosticRuleSet.reportUnboundVariable === 'none') {
+            return;
+        }
+        if (!AnalyzerNodeInfo.isCodeUnreachable(node)) {
+            const type = this._evaluator.getType(node);
+            if (type) {
+                if ((0, types_1.isUnbound)(type)) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnboundVariable, diagnosticRules_1.DiagnosticRule.reportUnboundVariable, localize_1.Localizer.Diagnostic.symbolIsUnbound().format({ name: node.value }), node);
+                }
+                else if ((0, types_1.isPossiblyUnbound)(type)) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnboundVariable, diagnosticRules_1.DiagnosticRule.reportUnboundVariable, localize_1.Localizer.Diagnostic.symbolIsPossiblyUnbound().format({ name: node.value }), node);
+                }
+            }
+        }
+    }
+    _conditionallyReportPrivateUsage(node) {
+        var _a;
+        if (this._fileInfo.diagnosticRuleSet.reportPrivateUsage === 'none') {
+            return;
+        }
+        // Ignore privates in type stubs.
+        if (this._fileInfo.isStubFile) {
+            return;
+        }
+        // Ignore privates in named arguments.
+        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 1 /* Argument */ && node.parent.name === node) {
+            return;
+        }
+        const nameValue = node.value;
+        const isPrivateName = SymbolNameUtils.isPrivateName(nameValue);
+        const isProtectedName = SymbolNameUtils.isProtectedName(nameValue);
+        // If it's not a protected or private name, don't bother with
+        // any further checks.
+        if (!isPrivateName && !isProtectedName) {
+            return;
+        }
+        const declarations = this._evaluator.getDeclarationsForNameNode(node);
+        let primaryDeclaration = declarations && declarations.length > 0 ? declarations[declarations.length - 1] : undefined;
+        if (!primaryDeclaration || primaryDeclaration.node === node) {
+            return;
+        }
+        if (primaryDeclaration.type === 6 /* Alias */) {
+            // If this symbol is an import alias (i.e. it's a local name rather than the
+            // original imported name), skip the private check.
+            if (primaryDeclaration.usesLocalName) {
+                return;
+            }
+            const resolvedAliasInfo = this._evaluator.resolveAliasDeclarationWithInfo(primaryDeclaration, 
+            /* resolveLocalNames */ true);
+            if (!resolvedAliasInfo) {
+                return;
+            }
+            primaryDeclaration = resolvedAliasInfo.declaration;
+            // If the alias resolved to a stub file or py.typed source file
+            // and the declaration is marked "externally visible", it is
+            // exempt from private usage checks.
+            if (!resolvedAliasInfo.isPrivate) {
+                return;
+            }
+        }
+        if (!primaryDeclaration || primaryDeclaration.node === node) {
+            return;
+        }
+        let classNode;
+        if (primaryDeclaration.node) {
+            classNode = ParseTreeUtils.getEnclosingClass(primaryDeclaration.node);
+        }
+        // If this is the name of a class, find the class that contains it rather
+        // than constraining the use of the class name within the class itself.
+        if (primaryDeclaration.node && primaryDeclaration.node.parent && primaryDeclaration.node.parent === classNode) {
+            classNode = ParseTreeUtils.getEnclosingClass(classNode);
+        }
+        // If it's a class member, check whether it's a legal protected access.
+        let isProtectedAccess = false;
+        if (classNode) {
+            if (isProtectedName) {
+                const declClassTypeInfo = this._evaluator.getTypeOfClass(classNode);
+                if (declClassTypeInfo && (0, types_1.isInstantiableClass)(declClassTypeInfo.decoratedType)) {
+                    // If it's a member defined in a stub file, we'll assume that it's part
+                    // of the public contract even if it's named as though it's private.
+                    if (types_1.ClassType.isDefinedInStub(declClassTypeInfo.decoratedType)) {
+                        return;
+                    }
+                    // Note that the access is to a protected class member.
+                    isProtectedAccess = true;
+                    const enclosingClassNode = ParseTreeUtils.getEnclosingClass(node);
+                    if (enclosingClassNode) {
+                        const enclosingClassTypeInfo = this._evaluator.getTypeOfClass(enclosingClassNode);
+                        // If the referencing class is a subclass of the declaring class, it's
+                        // allowed to access a protected name.
+                        if (enclosingClassTypeInfo && (0, types_1.isInstantiableClass)(enclosingClassTypeInfo.decoratedType)) {
+                            if ((0, typeUtils_1.derivesFromClassRecursive)(enclosingClassTypeInfo.decoratedType, declClassTypeInfo.decoratedType, 
+                            /* ignoreUnknown */ true)) {
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (classNode && !ParseTreeUtils.isNodeContainedWithin(node, classNode)) {
+            if (isProtectedAccess) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportPrivateUsage, diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.Localizer.Diagnostic.protectedUsedOutsideOfClass().format({ name: nameValue }), node);
+            }
+            else {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportPrivateUsage, diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.Localizer.Diagnostic.privateUsedOutsideOfClass().format({ name: nameValue }), node);
+            }
+        }
+    }
+    // Validates that an enum class does not attempt to override another
+    // enum class that has already defined values.
+    _validateEnumClassOverride(node, classType) {
+        classType.details.baseClasses.forEach((baseClass, index) => {
+            if ((0, types_1.isClass)(baseClass) && types_1.ClassType.isEnumClass(baseClass)) {
+                // Determine whether the base enum class defines an enumerated value.
+                let baseEnumDefinesValue = false;
+                baseClass.details.fields.forEach((symbol) => {
+                    const symbolType = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+                    if ((0, types_1.isClassInstance)(symbolType) && types_1.ClassType.isSameGenericClass(symbolType, baseClass)) {
+                        baseEnumDefinesValue = true;
+                    }
+                });
+                if (baseEnumDefinesValue) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.enumClassOverride().format({ name: baseClass.details.name }), node.arguments[index]);
+                }
+            }
+        });
+    }
+    // Verifies the rules specified in PEP 589 about TypedDict classes.
+    // They cannot have statements other than type annotations, doc
+    // strings, and "pass" statements or ellipses.
+    _validateTypedDictClassSuite(suiteNode) {
+        const emitBadStatementError = (node) => {
+            this._evaluator.addError(localize_1.Localizer.Diagnostic.typedDictBadVar(), node);
+        };
+        suiteNode.statements.forEach((statement) => {
+            if (!AnalyzerNodeInfo.isCodeUnreachable(statement)) {
+                if (statement.nodeType === 47 /* StatementList */) {
+                    for (const substatement of statement.statements) {
+                        if (substatement.nodeType !== 54 /* TypeAnnotation */ &&
+                            substatement.nodeType !== 18 /* Ellipsis */ &&
+                            substatement.nodeType !== 48 /* StringList */ &&
+                            substatement.nodeType !== 42 /* Pass */) {
+                            emitBadStatementError(substatement);
+                        }
+                    }
+                }
+                else {
+                    emitBadStatementError(statement);
+                }
+            }
+        });
+    }
+    _validateStrictTypeGuardFunction(node, functionType, isMethod) {
+        var _a;
+        // Is this a strict type guard function?
+        if (!functionType.details.declaredReturnType) {
+            return;
+        }
+        if (!(0, types_1.isClassInstance)(functionType.details.declaredReturnType) ||
+            !types_1.ClassType.isBuiltIn(functionType.details.declaredReturnType, 'StrictTypeGuard') ||
+            !functionType.details.declaredReturnType.typeArguments ||
+            functionType.details.declaredReturnType.typeArguments.length < 1) {
+            return;
+        }
+        const typeGuardType = functionType.details.declaredReturnType.typeArguments[0];
+        // Determine the type of the first parameter.
+        const paramIndex = isMethod && !types_1.FunctionType.isStaticMethod(functionType) ? 1 : 0;
+        if (paramIndex >= functionType.details.parameters.length) {
+            return;
+        }
+        const paramType = types_1.FunctionType.getEffectiveParameterType(functionType, paramIndex);
+        // Verify that the typeGuardType is a narrower type than the paramType.
+        if (!this._evaluator.assignType(paramType, typeGuardType)) {
+            const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
+            if (returnAnnotation) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.strictTypeGuardReturnType().format({
+                    type: this._evaluator.printType(paramType),
+                    returnType: this._evaluator.printType(typeGuardType),
+                }), returnAnnotation);
+            }
+        }
+    }
+    _validateDunderSignatures(node, functionType, isMethod) {
+        var _a;
+        const functionName = functionType.details.name;
+        // Is this an '__init__' method? Verify that it returns None.
+        if (isMethod && functionName === '__init__') {
+            const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
+            const declaredReturnType = functionType.details.declaredReturnType;
+            if (returnAnnotation && declaredReturnType) {
+                if (!(0, types_1.isNoneInstance)(declaredReturnType) && !(0, types_1.isNever)(declaredReturnType)) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.initMustReturnNone(), returnAnnotation);
+                }
+            }
+            else {
+                const inferredReturnType = this._evaluator.getFunctionInferredReturnType(functionType);
+                if (!(0, types_1.isNever)(inferredReturnType) &&
+                    !(0, types_1.isNoneInstance)(inferredReturnType) &&
+                    !(0, types_1.isAnyOrUnknown)(inferredReturnType)) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.initMustReturnNone(), node.name);
+                }
+            }
+        }
+    }
+    _validateFunctionReturn(node, functionType) {
+        var _a;
+        // Stub files are allowed not to return an actual value,
+        // so skip this if it's a stub file.
+        if (this._fileInfo.isStubFile) {
+            return;
+        }
+        const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
+        if (returnAnnotation) {
+            const functionNeverReturns = !this._evaluator.isAfterNodeReachable(node);
+            const implicitlyReturnsNone = this._evaluator.isAfterNodeReachable(node.suite);
+            let declaredReturnType = functionType.details.declaredReturnType;
+            if (declaredReturnType) {
+                if ((0, types_1.isUnknown)(declaredReturnType)) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.declaredReturnTypeUnknown(), returnAnnotation);
+                }
+                else if ((0, typeUtils_1.isPartlyUnknown)(declaredReturnType)) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.declaredReturnTypePartiallyUnknown().format({
+                        returnType: this._evaluator.printType(declaredReturnType, /* expandTypeAlias */ true),
+                    }), returnAnnotation);
+                }
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                if ((0, types_1.isTypeVar)(declaredReturnType) && declaredReturnType.details.variance === 2 /* Contravariant */) {
+                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarIsContravariant().format({
+                        name: types_1.TypeVarType.getReadableName(declaredReturnType),
+                    }));
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeContravariant() + diag.getString(), returnAnnotation);
+                }
+            }
+            // Wrap the declared type in a generator type if the function is a generator.
+            if (types_1.FunctionType.isGenerator(functionType)) {
+                declaredReturnType = (0, typeUtils_1.getDeclaredGeneratorReturnType)(functionType);
+            }
+            // The types of all return statement expressions were already checked
+            // against the declared type, but we need to verify the implicit None
+            // at the end of the function.
+            if (declaredReturnType && !functionNeverReturns && implicitlyReturnsNone) {
+                if ((0, types_1.isNever)(declaredReturnType)) {
+                    // If the function consists entirely of "...", assume that it's
+                    // an abstract method or a protocol method and don't require that
+                    // the return type matches. This check can also be skipped for an overload.
+                    if (!ParseTreeUtils.isSuiteEmpty(node.suite) && !types_1.FunctionType.isOverloaded(functionType)) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noReturnReturnsNone(), returnAnnotation);
+                    }
+                }
+                else if (!types_1.FunctionType.isAbstractMethod(functionType)) {
+                    // Make sure that the function doesn't implicitly return None if the declared
+                    // type doesn't allow it. Skip this check for abstract methods.
+                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    // If the declared type isn't compatible with 'None', flag an error.
+                    if (!this._evaluator.assignType(declaredReturnType, types_1.NoneType.createInstance(), diagAddendum)) {
+                        // If the function consists entirely of "...", assume that it's
+                        // an abstract method or a protocol method and don't require that
+                        // the return type matches. This check can also be skipped for an overload.
+                        if (!ParseTreeUtils.isSuiteEmpty(node.suite) && !types_1.FunctionType.isOverloaded(functionType)) {
+                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnMissing().format({
+                                returnType: this._evaluator.printType(declaredReturnType, 
+                                /* expandTypeAlias */ false),
+                            }) + diagAddendum.getString(), returnAnnotation);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            const inferredReturnType = this._evaluator.getFunctionInferredReturnType(functionType);
+            if ((0, types_1.isUnknown)(inferredReturnType)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.name);
+            }
+            else if ((0, typeUtils_1.isPartlyUnknown)(inferredReturnType)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.returnTypePartiallyUnknown().format({
+                    returnType: this._evaluator.printType(inferredReturnType, /* expandTypeAlias */ true),
+                }), node.name);
+            }
+        }
+    }
+    // Validates that any overridden member variables are not marked
+    // as Final in parent classes.
+    _validateFinalMemberOverrides(classType) {
+        classType.details.fields.forEach((localSymbol, name) => {
+            const parentSymbol = (0, typeUtils_1.lookUpClassMember)(classType, name, 1 /* SkipOriginalClass */);
+            if (parentSymbol &&
+                (0, types_1.isInstantiableClass)(parentSymbol.classType) &&
+                (0, symbolUtils_1.isFinalVariable)(parentSymbol.symbol) &&
+                !SymbolNameUtils.isPrivateName(name)) {
+                const decl = localSymbol.getDeclarations()[0];
+                this._evaluator.addError(localize_1.Localizer.Diagnostic.finalRedeclarationBySubclass().format({
+                    name,
+                    className: parentSymbol.classType.details.name,
+                }), decl.node);
+            }
+        });
+    }
+    _reportDuplicateEnumMembers(classType) {
+        if (!types_1.ClassType.isEnumClass(classType) || types_1.ClassType.isBuiltIn(classType)) {
+            return;
+        }
+        classType.details.fields.forEach((symbol, name) => {
+            // Enum members don't have type annotations.
+            if (symbol.getTypedDeclarations().length > 0) {
+                return;
+            }
+            const decls = symbol.getDeclarations();
+            if (decls.length >= 2 && decls[0].type === 1 /* Variable */) {
+                const symbolType = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+                // Is this symbol a literal instance of the enum class?
+                if ((0, types_1.isClassInstance)(symbolType) &&
+                    types_1.ClassType.isSameGenericClass(symbolType, classType) &&
+                    symbolType.literalValue !== undefined) {
+                    this._evaluator.addError(localize_1.Localizer.Diagnostic.duplicateEnumMember().format({ name }), decls[1].node);
+                }
+            }
+        });
+    }
+    // If a non-protocol class explicitly inherits from a protocol class, this method
+    // verifies that any class or instance variables declared but not assigned
+    // in the protocol class are implemented in the subclass. It also checks that any
+    // empty functions declared in the protocol are implemented in the subclass.
+    _validateProtocolCompatibility(classType, errorNode) {
+        if (types_1.ClassType.isProtocolClass(classType)) {
+            return;
+        }
+        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        const isSymbolImplemented = (name) => {
+            return classType.details.mro.some((mroClass) => {
+                return (0, types_1.isClass)(mroClass) && !types_1.ClassType.isProtocolClass(mroClass) && mroClass.details.fields.has(name);
+            });
+        };
+        classType.details.baseClasses.forEach((baseClass) => {
+            if (!(0, types_1.isClass)(baseClass) || !types_1.ClassType.isProtocolClass(baseClass)) {
+                return;
+            }
+            const protocolSymbols = (0, typeUtils_1.getProtocolSymbols)(baseClass);
+            protocolSymbols.forEach((member, name) => {
+                const decls = member.symbol.getDeclarations();
+                if (decls.length === 0 || !(0, types_1.isClass)(member.classType)) {
+                    return;
+                }
+                if (decls[0].type === 1 /* Variable */) {
+                    // If none of the declarations involve assignments, assume it's
+                    // not implemented in the protocol.
+                    if (!decls.some((decl) => decl.type === 1 /* Variable */ && !!decl.inferredTypeSource)) {
+                        // This is a variable declaration that is not implemented in the
+                        // protocol base class. Make sure it's implemented in the derived class.
+                        if (!isSymbolImplemented(name)) {
+                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
+                                name,
+                                classType: member.classType.details.name,
+                            }));
+                        }
+                    }
+                }
+                else if (decls[0].type === 3 /* Function */) {
+                    if (ParseTreeUtils.isSuiteEmpty(decls[0].node.suite) && decls[0]) {
+                        if ((0, pathUtils_1.getFileExtension)(decls[0].path).toLowerCase() !== '.pyi') {
+                            if (!isSymbolImplemented(name)) {
+                                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
+                                    name,
+                                    classType: member.classType.details.name,
+                                }));
+                            }
+                        }
+                    }
+                }
+            });
+        });
+        if (!diagAddendum.isEmpty()) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.missingProtocolMembers() + diagAddendum.getString(), errorNode.name);
+        }
+    }
+    // If a class is a dataclass with a `__post_init__` method, verify that its
+    // signature is correct.
+    _validateDataClassPostInit(classType, errorNode) {
+        if (!types_1.ClassType.isDataClass(classType)) {
+            return;
+        }
+        const postInitMember = (0, typeUtils_1.lookUpClassMember)(classType, '__post_init__', 2 /* SkipBaseClasses */ | 16 /* DeclaredTypesOnly */);
+        // If there's no __post_init__ method, there's nothing to check.
+        if (!postInitMember) {
+            return;
+        }
+        // If the class derives from Any, we can't reliably apply the check.
+        if (types_1.ClassType.derivesFromAnyOrUnknown(classType)) {
+            return;
+        }
+        // Collect the list of init-only variables in the order they were declared.
+        const initOnlySymbolMap = new Map();
+        for (let i = classType.details.mro.length - 1; i >= 0; i--) {
+            const mroClass = classType.details.mro[i];
+            if ((0, types_1.isClass)(mroClass) && types_1.ClassType.isDataClass(mroClass)) {
+                mroClass.details.fields.forEach((symbol, name) => {
+                    if (symbol.isInitVar()) {
+                        initOnlySymbolMap.set(name, symbol);
+                    }
+                });
+            }
+        }
+        const postInitType = this._evaluator.getTypeOfMember(postInitMember);
+        if (!(0, types_1.isFunction)(postInitType) ||
+            !types_1.FunctionType.isInstanceMethod(postInitType) ||
+            !postInitType.details.declaration) {
+            return;
+        }
+        const paramListDetails = (0, typeUtils_1.getParameterListDetails)(postInitType);
+        // If there is an *args or **kwargs parameter or a keyword-only separator,
+        // don't bother checking.
+        if (paramListDetails.argsIndex !== undefined ||
+            paramListDetails.kwargsIndex !== undefined ||
+            paramListDetails.firstKeywordOnlyIndex !== undefined) {
+            return;
+        }
+        // Verify that the parameter count matches.
+        const nonDefaultParams = paramListDetails.params.filter((paramInfo) => !paramInfo.param.hasDefault);
+        // We expect to see one param for "self" plus one for each of the InitVars.
+        const expectedParamCount = initOnlySymbolMap.size + 1;
+        if (expectedParamCount < nonDefaultParams.length || expectedParamCount > paramListDetails.params.length) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassPostInitParamCount().format({ expected: initOnlySymbolMap.size }), postInitType.details.declaration.node.name);
+        }
+        // Verify that the parameter types match.
+        let paramIndex = 1;
+        initOnlySymbolMap.forEach((symbol, fieldName) => {
+            if (paramIndex >= paramListDetails.params.length) {
+                return;
+            }
+            const param = paramListDetails.params[paramIndex].param;
+            if (param.hasDeclaredType && param.typeAnnotation) {
+                const fieldType = this._evaluator.getDeclaredTypeOfSymbol(symbol);
+                const paramType = types_1.FunctionType.getEffectiveParameterType(postInitType, paramListDetails.params[paramIndex].index);
+                const assignTypeDiag = new diagnostic_1.DiagnosticAddendum();
+                if (fieldType && !this._evaluator.assignType(paramType, fieldType, assignTypeDiag)) {
+                    const diagnostic = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassPostInitType().format({ fieldName }) + assignTypeDiag.getString(), param.typeAnnotation);
+                    if (diagnostic) {
+                        const fieldDecls = symbol.getTypedDeclarations();
+                        if (fieldDecls.length > 0) {
+                            diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.dataClassFieldLocation(), fieldDecls[0].path, fieldDecls[0].range);
+                        }
+                    }
+                }
+            }
+            paramIndex++;
+        });
+    }
+    // If a class is marked final, it must implement all abstract methods,
+    // otherwise it is of no use.
+    _validateFinalClassNotAbstract(classType, errorNode) {
+        if (!types_1.ClassType.isFinal(classType)) {
+            return;
+        }
+        if (!types_1.ClassType.supportsAbstractMethods(classType)) {
+            return;
+        }
+        const abstractMethods = this._evaluator.getAbstractMethods(classType);
+        if (abstractMethods.length === 0) {
+            return;
+        }
+        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        const errorsToDisplay = 2;
+        abstractMethods.forEach((abstractMethod, index) => {
+            if (index === errorsToDisplay) {
+                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsAbstractMore().format({
+                    count: abstractMethods.length - errorsToDisplay,
+                }));
+            }
+            else if (index < errorsToDisplay) {
+                if ((0, types_1.isInstantiableClass)(abstractMethod.classType)) {
+                    const className = abstractMethod.classType.details.name;
+                    diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsAbstract().format({
+                        type: className,
+                        name: abstractMethod.symbolName,
+                    }));
+                }
+            }
+        });
+        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.finalClassIsAbstract().format({
+            type: classType.details.name,
+        }) + diagAddendum.getString(), errorNode.name);
+    }
+    // Reports the case where an instance variable is not declared or initialized
+    // within the class body or constructor method.
+    _validateInstanceVariableInitialization(classType) {
+        // This check can be expensive, so don't perform it if the corresponding
+        // rule is disabled.
+        if (this._fileInfo.diagnosticRuleSet.reportUninitializedInstanceVariable === 'none') {
+            return;
+        }
+        classType.details.fields.forEach((localSymbol, name) => {
+            // This applies only to instance members.
+            if (!localSymbol.isInstanceMember()) {
+                return;
+            }
+            const decls = localSymbol.getDeclarations();
+            // If the symbol is assigned (or at least declared) within the
+            // class body or within the __init__ method, it can be ignored.
+            if (decls.find((decl) => {
+                var _a, _b, _c;
+                const containingClass = ParseTreeUtils.getEnclosingClassOrFunction(decl.node);
+                if (!containingClass) {
+                    return true;
+                }
+                if (containingClass.nodeType === 10 /* Class */) {
+                    // If this is part of an assignment statement, assume it has been
+                    // initialized as a class variable.
+                    if (((_a = decl.node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */) {
+                        return true;
+                    }
+                    if (((_b = decl.node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 54 /* TypeAnnotation */ &&
+                        ((_c = decl.node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
+                        return true;
+                    }
+                    // If this is part of a dataclass or a class handled by a dataclass_transform,
+                    // exempt it because the class variable will be transformed into an instance
+                    // variable in this case.
+                    if (types_1.ClassType.isDataClass(classType)) {
+                        return true;
+                    }
+                    // If this is part of a TypedDict, exempt it because the class variables
+                    // are not actually class variables in a TypedDict.
+                    if (types_1.ClassType.isTypedDictClass(classType)) {
+                        return true;
+                    }
+                }
+                if (containingClass.name.value === '__init__') {
+                    return true;
+                }
+                return false;
+            })) {
+                return;
+            }
+            // If the symbol is declared by its parent, we can assume it
+            // is initialized there.
+            const parentSymbol = (0, typeUtils_1.lookUpClassMember)(classType, name, 1 /* SkipOriginalClass */);
+            if (parentSymbol) {
+                return;
+            }
+            // Report the variable as uninitialized only on the first decl.
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUninitializedInstanceVariable, diagnosticRules_1.DiagnosticRule.reportUninitializedInstanceVariable, localize_1.Localizer.Diagnostic.uninitializedInstanceVariable().format({ name: name }), decls[0].node);
+        });
+    }
+    // Validates that the type variables used in a generic protocol class have
+    // the proper variance (invariant, covariant, contravariant). See PEP 544
+    // for an explanation for why this is important to enforce.
+    _validateProtocolTypeParamVariance(errorNode, classType) {
+        const origTypeParams = classType.details.typeParameters.filter((typeParam) => !(0, types_1.isParamSpec)(typeParam));
+        // If this isn't a generic protocol, there's nothing to do here.
+        if (origTypeParams.length === 0) {
+            return;
+        }
+        const objectType = this._evaluator.getBuiltInType(errorNode, 'object');
+        if (!(0, types_1.isInstantiableClass)(objectType)) {
+            return;
+        }
+        // Replace all of the type parameters with invariant TypeVars.
+        const updatedTypeParams = origTypeParams.map((typeParam) => (0, types_1.isVariadicTypeVar)(typeParam) ? typeParam : types_1.TypeVarType.cloneAsInvariant(typeParam));
+        const updatedClassType = types_1.ClassType.cloneWithNewTypeParameters(classType, updatedTypeParams);
+        const objectObject = types_1.ClassType.cloneAsInstance(objectType);
+        const dummyTypeObject = types_1.ClassType.createInstantiable('__protocolVarianceDummy', '', '', '', 0, 0, undefined, undefined);
+        updatedTypeParams.forEach((param, paramIndex) => {
+            // Skip variadics.
+            if (param.details.isVariadic) {
+                return;
+            }
+            // Replace all type arguments with a dummy type except for the
+            // TypeVar of interest, which is replaced with an object instance.
+            const srcTypeArgs = updatedTypeParams.map((p, i) => {
+                if (p.details.isVariadic) {
+                    return p;
+                }
+                return i === paramIndex ? objectObject : dummyTypeObject;
+            });
+            // Replace all type arguments with a dummy type except for the
+            // TypeVar of interest, which is replaced with itself.
+            const destTypeArgs = updatedTypeParams.map((p, i) => {
+                return i === paramIndex || p.details.isVariadic ? p : dummyTypeObject;
+            });
+            const srcType = types_1.ClassType.cloneForSpecialization(updatedClassType, srcTypeArgs, 
+            /* isTypeArgumentExplicit */ true);
+            const destType = types_1.ClassType.cloneForSpecialization(updatedClassType, destTypeArgs, 
+            /* isTypeArgumentExplicit */ true);
+            const isDestSubtypeOfSrc = (0, protocols_1.assignProtocolClassToSelf)(this._evaluator, srcType, destType);
+            let expectedVariance;
+            if (isDestSubtypeOfSrc) {
+                expectedVariance = 1 /* Covariant */;
+            }
+            else {
+                const isSrcSubtypeOfDest = (0, protocols_1.assignProtocolClassToSelf)(this._evaluator, destType, srcType);
+                if (isSrcSubtypeOfDest) {
+                    expectedVariance = 2 /* Contravariant */;
+                }
+                else {
+                    expectedVariance = 0 /* Invariant */;
+                }
+            }
+            if (expectedVariance !== origTypeParams[paramIndex].details.variance) {
+                let message;
+                if (expectedVariance === 1 /* Covariant */) {
+                    message = localize_1.Localizer.Diagnostic.protocolVarianceCovariant().format({
+                        variable: param.details.name,
+                        class: classType.details.name,
+                    });
+                }
+                else if (expectedVariance === 2 /* Contravariant */) {
+                    message = localize_1.Localizer.Diagnostic.protocolVarianceContravariant().format({
+                        variable: param.details.name,
+                        class: classType.details.name,
+                    });
+                }
+                else {
+                    message = localize_1.Localizer.Diagnostic.protocolVarianceInvariant().format({
+                        variable: param.details.name,
+                        class: classType.details.name,
+                    });
+                }
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidTypeVarUse, diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, message, errorNode.name);
+            }
+        });
+    }
+    // Validates that a class variable doesn't conflict with a __slots__
+    // name. This will generate a runtime exception.
+    _validateSlotsClassVarConflict(classType) {
+        if (!classType.details.localSlotsNames) {
+            // Nothing to check, since this class doesn't use __slots__.
+            return;
+        }
+        // Don't apply this for dataclasses because their class variables
+        // are transformed into instance variables.
+        if (types_1.ClassType.isDataClass(classType)) {
+            return;
+        }
+        classType.details.fields.forEach((symbol, name) => {
+            const decls = symbol.getDeclarations();
+            const isDefinedBySlots = decls.some((decl) => decl.type === 1 /* Variable */ && decl.isDefinedBySlots);
+            if (isDefinedBySlots) {
+                decls.forEach((decl) => {
+                    if (decl.type === 1 /* Variable */ &&
+                        !decl.isDefinedBySlots &&
+                        !decl.isDefinedByMemberAccess) {
+                        if (decl.node.nodeType === 38 /* Name */ && ParseTreeUtils.isWriteAccess(decl.node)) {
+                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.slotsClassVarConflict().format({ name }), decl.node);
+                        }
+                    }
+                });
+            }
+        });
+    }
+    // Validates that the __init__ and __new__ method signatures are consistent.
+    _validateConstructorConsistency(classType) {
+        const initMember = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 4 /* SkipObjectBaseClass */ | 8 /* SkipInstanceVariables */);
+        const newMember = (0, typeUtils_1.lookUpClassMember)(classType, '__new__', 4 /* SkipObjectBaseClass */ | 8 /* SkipInstanceVariables */);
+        if (!initMember || !newMember || !(0, types_1.isClass)(initMember.classType) || !(0, types_1.isClass)(newMember.classType)) {
+            return;
+        }
+        // If both the __new__ and __init__ come from subclasses, don't bother
+        // checking for this class.
+        if (!types_1.ClassType.isSameGenericClass(newMember.classType, classType) &&
+            !types_1.ClassType.isSameGenericClass(initMember.classType, classType)) {
+            return;
+        }
+        // If the class that provides the __new__ method has a custom metaclass with a
+        // __call__ method, skip this check.
+        const metaclass = newMember.classType.details.effectiveMetaclass;
+        if (metaclass && (0, types_1.isClass)(metaclass) && !types_1.ClassType.isBuiltIn(metaclass, 'type')) {
+            const callMethod = (0, typeUtils_1.lookUpClassMember)(metaclass, '__call__', 32 /* SkipTypeBaseClass */ | 8 /* SkipInstanceVariables */);
+            if (callMethod) {
+                return;
+            }
+        }
+        let newMemberType = this._evaluator.getTypeOfMember(newMember);
+        if (!(0, types_1.isFunction)(newMemberType) && !(0, types_1.isOverloadedFunction)(newMemberType)) {
+            return;
+        }
+        newMemberType = this._evaluator.bindFunctionToClassOrObject(classType, newMemberType, 
+        /* memberClass */ undefined, 
+        /* errorNode */ undefined, 
+        /* recursionCount */ undefined, 
+        /* treatConstructorAsClassMember */ true);
+        if (!newMemberType) {
+            return;
+        }
+        if ((0, types_1.isOverloadedFunction)(newMemberType)) {
+            // Find the implementation, not the overloaded signatures.
+            newMemberType = newMemberType.overloads.find((func) => !types_1.FunctionType.isOverloaded(func));
+            if (!newMemberType) {
+                return;
+            }
+        }
+        let initMemberType = this._evaluator.getTypeOfMember(initMember);
+        if (!(0, types_1.isFunction)(initMemberType) && !(0, types_1.isOverloadedFunction)(initMemberType)) {
+            return;
+        }
+        initMemberType = this._evaluator.bindFunctionToClassOrObject(types_1.ClassType.cloneAsInstance(classType), initMemberType);
+        if (!initMemberType) {
+            return;
+        }
+        if ((0, types_1.isOverloadedFunction)(initMemberType)) {
+            // Find the implementation, not the overloaded signatures.
+            initMemberType = initMemberType.overloads.find((func) => !types_1.FunctionType.isOverloaded(func));
+            if (!initMemberType) {
+                return;
+            }
+        }
+        if (!(0, types_1.isFunction)(initMemberType) || !(0, types_1.isFunction)(newMemberType)) {
+            return;
+        }
+        // If either of the functions has a default parameter signature
+        // (* args: Any, ** kwargs: Any), don't proceed with the check.
+        if (types_1.FunctionType.hasDefaultParameters(initMemberType) || types_1.FunctionType.hasDefaultParameters(newMemberType)) {
+            return;
+        }
+        // We'll set the "SkipArgsKwargs" flag for pragmatic reasons since __new__
+        // often has an *args and/or **kwargs. We'll also set the ParamSpecValue
+        // because we don't care about the return type for this check.
+        initMemberType = types_1.FunctionType.cloneWithNewFlags(initMemberType, initMemberType.details.flags |
+            32768 /* SkipArgsKwargsCompatibilityCheck */ |
+            65536 /* ParamSpecValue */);
+        newMemberType = types_1.FunctionType.cloneWithNewFlags(newMemberType, initMemberType.details.flags |
+            32768 /* SkipArgsKwargsCompatibilityCheck */ |
+            65536 /* ParamSpecValue */);
+        if (!this._evaluator.assignType(newMemberType, initMemberType, 
+        /* diag */ undefined, 
+        /* destTypeVarContext */ undefined, 
+        /* srcTypeVarContext */ undefined, 32 /* SkipFunctionReturnTypeCheck */) ||
+            !this._evaluator.assignType(initMemberType, newMemberType, 
+            /* diag */ undefined, 
+            /* destTypeVarContext */ undefined, 
+            /* srcTypeVarContext */ undefined, 32 /* SkipFunctionReturnTypeCheck */)) {
+            const displayOnInit = types_1.ClassType.isSameGenericClass(initMember.classType, classType);
+            const initDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(initMember.symbol);
+            const newDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(newMember.symbol);
+            if (initDecl && newDecl) {
+                const mainDecl = displayOnInit ? initDecl : newDecl;
+                const mainDeclNode = mainDecl.node.nodeType === 28 /* Function */ ? mainDecl.node.name : mainDecl.node;
+                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                const initSignature = this._evaluator.printType(initMemberType);
+                const newSignature = this._evaluator.printType(newMemberType);
+                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.initMethodSignature().format({
+                    type: initSignature,
+                }));
+                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.newMethodSignature().format({
+                    type: newSignature,
+                }));
+                const diagnostic = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInconsistentConstructor, diagnosticRules_1.DiagnosticRule.reportInconsistentConstructor, localize_1.Localizer.Diagnostic.constructorParametersMismatch().format({
+                    classType: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? initMember.classType : newMember.classType)),
+                }) + diagAddendum.getString(), mainDeclNode);
+                if (diagnostic) {
+                    const secondaryDecl = displayOnInit ? newDecl : initDecl;
+                    diagnostic.addRelatedInfo((displayOnInit
+                        ? localize_1.Localizer.DiagnosticAddendum.newMethodLocation()
+                        : localize_1.Localizer.DiagnosticAddendum.initMethodLocation()).format({
+                        type: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? newMember.classType : initMember.classType)),
+                    }), secondaryDecl.path, secondaryDecl.range);
+                }
+            }
+        }
+    }
+    // Validates that any methods and variables in multiple base classes are
+    // compatible with each other.
+    _validateMultipleInheritanceCompatibility(classType, errorNode) {
+        // Skip this check if reportIncompatibleMethodOverride and reportIncompatibleVariableOverride
+        // are disabled because it's a relatively expensive check.
+        if (this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride === 'none' &&
+            this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride === 'none') {
+            return;
+        }
+        const baseClasses = [];
+        // Filter any unknown base classes. Also remove Generic and Protocol
+        // base classes.
+        classType.details.baseClasses.forEach((baseClass) => {
+            if ((0, types_1.isClass)(baseClass) &&
+                !types_1.ClassType.isBuiltIn(baseClass, 'Generic') &&
+                !types_1.ClassType.isBuiltIn(baseClass, 'Protocol')) {
+                baseClasses.push(baseClass);
+            }
+        });
+        // If there is only one base class, there's nothing to do.
+        if (baseClasses.length < 2) {
+            return;
+        }
+        // Build maps of symbols for each of the base classes.
+        const symbolMaps = baseClasses.map((baseClass) => {
+            const specializedBaseClass = classType.details.mro.find((c) => (0, types_1.isClass)(c) && types_1.ClassType.isSameGenericClass(c, baseClass));
+            if (!specializedBaseClass || !(0, types_1.isClass)(specializedBaseClass)) {
+                return new Map();
+            }
+            // Retrieve all of the specialized symbols from the base class and its ancestors.
+            return (0, typeUtils_1.getClassFieldsRecursive)(specializedBaseClass);
+        });
+        for (let symbolMapBaseIndex = 1; symbolMapBaseIndex < symbolMaps.length; symbolMapBaseIndex++) {
+            const baseSymbolMap = symbolMaps[symbolMapBaseIndex];
+            for (const [name, baseClassAndSymbol] of baseSymbolMap) {
+                // Special-case dundered methods, which can differ in signature. Also
+                // exempt private symbols.
+                if (SymbolNameUtils.isDunderName(name) || SymbolNameUtils.isPrivateName(name)) {
+                    continue;
+                }
+                const baseClassType = baseClassAndSymbol.classType;
+                if (!(0, types_1.isClass)(baseClassType)) {
+                    continue;
+                }
+                for (let overrideIndex = 0; overrideIndex < symbolMapBaseIndex; overrideIndex++) {
+                    const overrideSymbolMap = symbolMaps[overrideIndex];
+                    const overrideClassAndSymbol = overrideSymbolMap.get(name);
+                    if (overrideClassAndSymbol) {
+                        this._validateMultipleInheritanceOverride(baseClassAndSymbol, overrideClassAndSymbol, classType, name, baseClasses[symbolMapBaseIndex], baseClasses[overrideIndex], errorNode);
+                    }
+                }
+            }
+        }
+    }
+    _validateMultipleInheritanceOverride(baseClassAndSymbol, overrideClassAndSymbol, childClassType, memberName, baseClass1, baseClass2, errorNode) {
+        if (!(0, types_1.isClass)(baseClassAndSymbol.classType) || !(0, types_1.isClass)(overrideClassAndSymbol.classType)) {
+            return;
+        }
+        // Special case the '_' symbol, which is used in single dispatch
+        // code and other cases where the name does not matter.
+        if (memberName === '_') {
+            return;
+        }
+        let baseType = this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol);
+        baseType = (0, typeUtils_1.partiallySpecializeType)(baseType, baseClassAndSymbol.classType);
+        const overrideSymbol = overrideClassAndSymbol.symbol;
+        let overrideType = this._evaluator.getEffectiveTypeOfSymbol(overrideSymbol);
+        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, overrideClassAndSymbol.classType);
+        let diag;
+        const overrideDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideClassAndSymbol.symbol);
+        const baseDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
+        if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
+            const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+            let overrideFunction;
+            if ((0, types_1.isFunction)(overrideType)) {
+                overrideFunction = overrideType;
+            }
+            else if ((0, types_1.isOverloadedFunction)(overrideType)) {
+                // Use the last overload.
+                overrideFunction = overrideType.overloads[overrideType.overloads.length - 1];
+                // If the last overload isn't an implementation, skip the check for this symbol.
+                if (types_1.FunctionType.isOverloaded(overrideFunction)) {
+                    return;
+                }
+            }
+            if (overrideFunction) {
+                if (!this._evaluator.validateOverrideMethod(baseType, overrideFunction, diagAddendum, 
+                /* enforceParamNameMatch */ true)) {
+                    const decl = overrideFunction.details.declaration;
+                    if (decl && decl.type === 3 /* Function */) {
+                        diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.baseClassMethodTypeIncompatible().format({
+                            classType: childClassType.details.name,
+                            name: memberName,
+                        }) + diagAddendum.getString(), errorNode);
+                    }
+                }
+            }
+        }
+        else if ((0, typeUtils_1.isProperty)(baseType)) {
+            // Handle properties specially.
+            if (!(0, typeUtils_1.isProperty)(overrideType) && !(0, types_1.isAnyOrUnknown)(overrideType)) {
+                const decls = overrideSymbol.getDeclarations();
+                if (decls.length > 0) {
+                    diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.baseClassVariableTypeIncompatible().format({
+                        classType: childClassType.details.name,
+                        name: memberName,
+                    }), errorNode);
+                }
+            }
+            else {
+                // TODO - check types of property methods fget, fset, fdel.
+            }
+        }
+        else {
+            // This check can be expensive, so don't perform it if the corresponding
+            // rule is disabled.
+            if (this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride !== 'none') {
+                if (!(0, types_1.isAnyOrUnknown)(baseType) && !(0, types_1.isAnyOrUnknown)(overrideType) && !(0, types_1.isTypeSame)(baseType, overrideType)) {
+                    diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.baseClassVariableTypeIncompatible().format({
+                        classType: childClassType.details.name,
+                        name: memberName,
+                    }), errorNode);
+                }
+            }
+        }
+        if (diag && overrideDecl && baseDecl) {
+            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.baseClassProvidesType().format({
+                baseClass: this._evaluator.printType((0, typeUtils_1.convertToInstance)(baseClass1)),
+                type: this._evaluator.printType(overrideType),
+            }), overrideDecl.path, overrideDecl.range);
+            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.baseClassProvidesType().format({
+                baseClass: this._evaluator.printType((0, typeUtils_1.convertToInstance)(baseClass2)),
+                type: this._evaluator.printType(baseType),
+            }), baseDecl.path, baseDecl.range);
+        }
+    }
+    // Validates that any overridden methods or variables contain the same
+    // types as the original method. Also marks the class as abstract if one
+    // or more abstract methods are not overridden.
+    _validateBaseClassOverrides(classType) {
+        classType.details.fields.forEach((symbol, name) => {
+            // Private symbols do not need to match in type since their
+            // names are mangled, and subclasses can't access the value in
+            // the parent class.
+            if (SymbolNameUtils.isPrivateName(name)) {
+                return;
+            }
+            // If the symbol has no declaration, and the type is inferred,
+            // skip this check.
+            if (!symbol.hasTypedDeclarations()) {
+                return;
+            }
+            // Get the symbol type defined in this class.
+            const typeOfSymbol = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+            // If the type of the override symbol isn't known, stop here.
+            if ((0, types_1.isAnyOrUnknown)(typeOfSymbol)) {
+                return;
+            }
+            for (const baseClass of classType.details.baseClasses) {
+                if (!(0, types_1.isClass)(baseClass)) {
+                    continue;
+                }
+                // Look up the base class in the MRO list. It's the same generic class
+                // but has already been specialized using the type variables of the classType.
+                const mroBaseClass = classType.details.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(mroClass, baseClass));
+                if (!mroBaseClass) {
+                    continue;
+                }
+                const baseClassAndSymbol = (0, typeUtils_1.lookUpClassMember)(mroBaseClass, name, 0 /* Default */);
+                if (!baseClassAndSymbol) {
+                    continue;
+                }
+                this._validateBaseClassOverride(baseClassAndSymbol, symbol, typeOfSymbol, classType, name);
+            }
+        });
+    }
+    _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
+        var _a;
+        if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
+            return;
+        }
+        // If the base class doesn't provide a type declaration, we won't bother
+        // proceeding with additional checks. Type inference is too inaccurate
+        // in this case, plus it would be very slow.
+        if (!baseClassAndSymbol.symbol.hasTypedDeclarations()) {
+            return;
+        }
+        // Special case the '_' symbol, which is used in single dispatch
+        // code and other cases where the name does not matter.
+        if (memberName === '_') {
+            return;
+        }
+        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClassAndSymbol.classType);
+        if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
+            const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+            let overrideFunction;
+            if ((0, types_1.isFunction)(overrideType)) {
+                overrideFunction = overrideType;
+            }
+            else if ((0, types_1.isOverloadedFunction)(overrideType)) {
+                // Use the last overload.
+                overrideFunction = overrideType.overloads[overrideType.overloads.length - 1];
+            }
+            if (overrideFunction) {
+                const exemptMethods = ['__init__', '__new__', '__init_subclass__'];
+                // Don't enforce parameter names for dundered methods. Many of them
+                // are misnamed in typeshed stubs, so this would result in many
+                // false positives.
+                const enforceParamNameMatch = !SymbolNameUtils.isDunderName(memberName);
+                // Don't check certain magic functions or private symbols.
+                if (!exemptMethods.some((exempt) => exempt === memberName) &&
+                    !SymbolNameUtils.isPrivateName(memberName)) {
+                    if (!this._evaluator.validateOverrideMethod(baseType, overrideFunction, diagAddendum, enforceParamNameMatch)) {
+                        const decl = (_a = overrideFunction.details.declaration) !== null && _a !== void 0 ? _a : (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
+                        if (decl) {
+                            const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.incompatibleMethodOverride().format({
+                                name: memberName,
+                                className: baseClassAndSymbol.classType.details.name,
+                            }) + diagAddendum.getString(), decl.type === 3 /* Function */ ? decl.node.name : decl.node);
+                            const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
+                            if (diag && origDecl) {
+                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.path, origDecl.range);
+                            }
+                        }
+                    }
+                }
+                if ((0, types_1.isFunction)(baseType)) {
+                    // Private names (starting with double underscore) are exempt from this check.
+                    if (!SymbolNameUtils.isPrivateName(memberName) && types_1.FunctionType.isFinal(baseType)) {
+                        const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
+                        if (decl && decl.type === 3 /* Function */) {
+                            const diag = this._evaluator.addError(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
+                                name: memberName,
+                                className: baseClassAndSymbol.classType.details.name,
+                            }), decl.node.name);
+                            const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
+                            if (diag && origDecl) {
+                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.finalMethod(), origDecl.path, origDecl.range);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (!(0, types_1.isAnyOrUnknown)(overrideType)) {
+                // Special-case overrides of methods in '_TypedDict', since
+                // TypedDict attributes aren't manifest as attributes but rather
+                // as named keys.
+                if (!types_1.ClassType.isBuiltIn(baseClassAndSymbol.classType, '_TypedDict')) {
+                    const decls = overrideSymbol.getDeclarations();
+                    if (decls.length > 0) {
+                        const lastDecl = decls[decls.length - 1];
+                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.methodOverridden().format({
+                            name: memberName,
+                            className: baseClassAndSymbol.classType.details.name,
+                            type: this._evaluator.printType(overrideType, /* expandTypeAlias */ false),
+                        }), lastDecl.node);
+                        const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
+                        if (diag && origDecl) {
+                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.path, origDecl.range);
+                        }
+                    }
+                }
+            }
+        }
+        else if ((0, typeUtils_1.isProperty)(baseType)) {
+            // Handle properties specially.
+            if (!(0, typeUtils_1.isProperty)(overrideType)) {
+                const decls = overrideSymbol.getDeclarations();
+                if (decls.length > 0) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
+                        name: memberName,
+                        className: baseClassAndSymbol.classType.details.name,
+                    }), decls[decls.length - 1].node);
+                }
+            }
+            else {
+                const basePropFields = baseType.details.fields;
+                const subclassPropFields = overrideType.details.fields;
+                const baseClassType = baseClassAndSymbol.classType;
+                ['fget', 'fset', 'fdel'].forEach((methodName) => {
+                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    const baseClassPropMethod = basePropFields.get(methodName);
+                    const subclassPropMethod = subclassPropFields.get(methodName);
+                    // Is the method present on the base class but missing in the subclass?
+                    if (baseClassPropMethod) {
+                        const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassPropMethod), baseClassType);
+                        if ((0, types_1.isFunction)(baseClassMethodType)) {
+                            if (!subclassPropMethod) {
+                                // The method is missing.
+                                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyMethodMissing().format({
+                                    name: methodName,
+                                }));
+                                const decls = overrideSymbol.getDeclarations();
+                                if (decls.length > 0) {
+                                    const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
+                                        name: memberName,
+                                        className: baseClassType.details.name,
+                                    }) + diagAddendum.getString(), decls[decls.length - 1].node);
+                                    const origDecl = baseClassMethodType.details.declaration;
+                                    if (diag && origDecl) {
+                                        diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.path, origDecl.range);
+                                    }
+                                }
+                            }
+                            else {
+                                const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(subclassPropMethod), childClassType);
+                                if ((0, types_1.isFunction)(subclassMethodType)) {
+                                    if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, diagAddendum.createAddendum())) {
+                                        diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyMethodIncompatible().format({
+                                            name: methodName,
+                                        }));
+                                        const decl = subclassMethodType.details.declaration;
+                                        if (decl && decl.type === 3 /* Function */) {
+                                            const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
+                                                name: memberName,
+                                                className: baseClassType.details.name,
+                                            }) + diagAddendum.getString(), decl.node.name);
+                                            const origDecl = baseClassMethodType.details.declaration;
+                                            if (diag && origDecl) {
+                                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.path, origDecl.range);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+            }
+        }
+        else {
+            // This check can be expensive, so don't perform it if the corresponding
+            // rule is disabled.
+            if (this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride !== 'none') {
+                const decls = overrideSymbol.getDeclarations();
+                if (decls.length > 0) {
+                    const lastDecl = decls[decls.length - 1];
+                    // Verify that the override type is assignable to (same or narrower than)
+                    // the declared type of the base symbol.
+                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    if (!this._evaluator.assignType(baseType, overrideType, diagAddendum)) {
+                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.symbolOverridden().format({
+                            name: memberName,
+                            className: baseClassAndSymbol.classType.details.name,
+                        }) + diagAddendum.getString(), lastDecl.node);
+                        const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
+                        if (diag && origDecl) {
+                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.path, origDecl.range);
+                        }
+                    }
+                    // Verify that a class variable isn't overriding an instance
+                    // variable or vice versa.
+                    const isBaseClassVar = baseClassAndSymbol.symbol.isClassVar();
+                    let isClassVar = overrideSymbol.isClassVar();
+                    if (isBaseClassVar && !isClassVar) {
+                        // If the subclass doesn't redeclare the type but simply assigns
+                        // it without declaring its type, we won't consider it an instance
+                        // variable.
+                        if (!overrideSymbol.hasTypedDeclarations()) {
+                            isClassVar = true;
+                        }
+                        // If the subclass is declaring an inner class, we'll consider that
+                        // to be a ClassVar.
+                        if (overrideSymbol.getTypedDeclarations().every((decl) => decl.type === 4 /* Class */)) {
+                            isClassVar = true;
+                        }
+                    }
+                    if (isBaseClassVar !== isClassVar) {
+                        const unformattedMessage = overrideSymbol.isClassVar()
+                            ? localize_1.Localizer.Diagnostic.classVarOverridesInstanceVar()
+                            : localize_1.Localizer.Diagnostic.instanceVarOverridesClassVar();
+                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
+                            name: memberName,
+                            className: baseClassAndSymbol.classType.details.name,
+                        }), lastDecl.node);
+                        const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
+                        if (diag && origDecl) {
+                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.path, origDecl.range);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Performs checks on a function that is located within a class
+    // and has been determined not to be a property accessor.
+    _validateMethod(node, functionType, classNode) {
+        const classTypeInfo = this._evaluator.getTypeOfClass(classNode);
+        const classType = classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.classType;
+        if (node.name && classType) {
+            const superCheckMethods = ['__init__', '__init_subclass__', '__enter__', '__exit__'];
+            if (superCheckMethods.some((name) => name === node.name.value)) {
+                if (!types_1.FunctionType.isAbstractMethod(functionType) &&
+                    !types_1.FunctionType.isOverloaded(functionType) &&
+                    !this._fileInfo.isStubFile) {
+                    this._validateSuperCallForMethod(node, functionType, classType);
+                }
+            }
+        }
+        if (node.name && node.name.value === '__new__') {
+            // __new__ overrides should have a "cls" parameter.
+            if (node.parameters.length === 0 ||
+                !node.parameters[0].name ||
+                !['cls', '_cls', '__cls', '__mcls'].some((name) => node.parameters[0].name.value === name)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.newClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+            }
+            if (classType) {
+                this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
+            }
+        }
+        else if (node.name && node.name.value === '__init_subclass__') {
+            // __init_subclass__ overrides should have a "cls" parameter.
+            if (node.parameters.length === 0 || !node.parameters[0].name || node.parameters[0].name.value !== 'cls') {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.initSubclassClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+            }
+            if (classType) {
+                this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
+            }
+        }
+        else if (node.name && node.name.value === '__class_getitem__') {
+            // __class_getitem__ overrides should have a "cls" parameter.
+            if (node.parameters.length === 0 || !node.parameters[0].name || node.parameters[0].name.value !== 'cls') {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.classGetItemClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+            }
+            if (classType) {
+                this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
+            }
+        }
+        else if (types_1.FunctionType.isStaticMethod(functionType)) {
+            // Static methods should not have "self" or "cls" parameters.
+            if (node.parameters.length > 0 && node.parameters[0].name) {
+                const paramName = node.parameters[0].name.value;
+                if (paramName === 'self' || paramName === 'cls') {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.staticClsSelfParam(), node.parameters[0].name);
+                }
+            }
+        }
+        else if (types_1.FunctionType.isClassMethod(functionType)) {
+            let paramName = '';
+            if (node.parameters.length > 0 && node.parameters[0].name) {
+                paramName = node.parameters[0].name.value;
+            }
+            // Class methods should have a "cls" parameter. We'll exempt parameter
+            // names that start with an underscore since those are used in a few
+            // cases in the stdlib pyi files.
+            if (paramName !== 'cls') {
+                if (!this._fileInfo.isStubFile || (!paramName.startsWith('_') && paramName !== 'metacls')) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.classMethodClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+                }
+            }
+            if (classType) {
+                this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
+            }
+        }
+        else {
+            // The presence of a decorator can change the behavior, so we need
+            // to back off from this check if a decorator is present.
+            if (node.decorators.length === 0) {
+                let paramName = '';
+                let firstParamIsSimple = true;
+                if (node.parameters.length > 0) {
+                    if (node.parameters[0].name) {
+                        paramName = node.parameters[0].name.value;
+                    }
+                    if (node.parameters[0].category !== 0 /* Simple */) {
+                        firstParamIsSimple = false;
+                    }
+                }
+                // Instance methods should have a "self" parameter.
+                if (firstParamIsSimple && paramName !== 'self') {
+                    // Special-case metaclasses, which can use "cls".
+                    let isLegalMetaclassName = false;
+                    if (paramName === 'cls') {
+                        const classTypeInfo = this._evaluator.getTypeOfClass(classNode);
+                        const typeType = this._evaluator.getBuiltInType(classNode, 'type');
+                        if (typeType &&
+                            (0, types_1.isInstantiableClass)(typeType) &&
+                            classTypeInfo &&
+                            (0, types_1.isInstantiableClass)(classTypeInfo.classType)) {
+                            if ((0, typeUtils_1.derivesFromClassRecursive)(classTypeInfo.classType, typeType, /* ignoreUnknown */ true)) {
+                                isLegalMetaclassName = true;
+                            }
+                        }
+                    }
+                    // Some typeshed stubs use a name that starts with an underscore to designate
+                    // a parameter that cannot be positional.
+                    const isPrivateName = SymbolNameUtils.isPrivateOrProtectedName(paramName);
+                    if (!isLegalMetaclassName && !isPrivateName) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.instanceMethodSelfParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+                    }
+                }
+            }
+            if (classType) {
+                this._validateClsSelfParameterType(functionType, classType, /* isCls */ false);
+            }
+        }
+    }
+    // Determines whether the method properly calls through to the same method in all
+    // parent classes that expose a same-named method.
+    _validateSuperCallForMethod(node, methodType, classType) {
+        // This is an expensive test, so if it's not enabled, don't do any work.
+        if (this._fileInfo.diagnosticRuleSet.reportMissingSuperCall === 'none') {
+            return;
+        }
+        // If the class is marked final, we can skip the "object" base class
+        // because we know that the `__init__` method in `object` doesn't do
+        // anything. It's not safe to do this if the class isn't final because
+        // it could be combined with other classes in a multi-inheritance
+        // situation that effectively adds new superclasses that we don't know
+        // about statically.
+        let effectiveFlags = 8 /* SkipInstanceVariables */ | 1 /* SkipOriginalClass */;
+        if (types_1.ClassType.isFinal(classType)) {
+            effectiveFlags |= 4 /* SkipObjectBaseClass */;
+        }
+        const methodMember = (0, typeUtils_1.lookUpClassMember)(classType, methodType.details.name, effectiveFlags);
+        if (!methodMember) {
+            return;
+        }
+        let foundCallOfMember = false;
+        // Now scan the implementation of the method to determine whether
+        // super().<method> has been called for all of the required base classes.
+        const callNodeWalker = new ParseTreeUtils.CallNodeWalker((node) => {
+            if (node.leftExpression.nodeType === 35 /* MemberAccess */) {
+                // Is it accessing the method by the same name?
+                if (node.leftExpression.memberName.value === methodType.details.name) {
+                    const memberBaseExpr = node.leftExpression.leftExpression;
+                    // Is it a "super" call?
+                    if (memberBaseExpr.nodeType === 9 /* Call */ &&
+                        memberBaseExpr.leftExpression.nodeType === 38 /* Name */ &&
+                        memberBaseExpr.leftExpression.value === 'super') {
+                        foundCallOfMember = true;
+                    }
+                    else {
+                        // Is it an X.<method> direct call?
+                        const baseType = this._evaluator.getType(memberBaseExpr);
+                        if (baseType && (0, types_1.isInstantiableClass)(baseType)) {
+                            foundCallOfMember = true;
+                        }
+                    }
+                }
+            }
+        });
+        callNodeWalker.walk(node.suite);
+        // If we didn't find a call to at least one base class, report the problem.
+        if (!foundCallOfMember) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingSuperCall, diagnosticRules_1.DiagnosticRule.reportMissingSuperCall, localize_1.Localizer.Diagnostic.missingSuperCall().format({
+                methodName: methodType.details.name,
+            }), node.name);
+        }
+    }
+    // Validates that the annotated type of a "self" or "cls" parameter is
+    // compatible with the type of the class that contains it.
+    _validateClsSelfParameterType(functionType, classType, isCls) {
+        if (functionType.details.parameters.length < 1) {
+            return;
+        }
+        // If there is no type annotation, there's nothing to check because
+        // the type will be inferred.
+        const paramInfo = functionType.details.parameters[0];
+        if (!paramInfo.typeAnnotation || !paramInfo.name) {
+            return;
+        }
+        // If this is a protocol class, the self and cls parameters can be bound
+        // to something other than the class.
+        if (types_1.ClassType.isProtocolClass(classType)) {
+            return;
+        }
+        const paramType = this._evaluator.makeTopLevelTypeVarsConcrete(paramInfo.type);
+        const expectedType = isCls ? classType : (0, typeUtils_1.convertToInstance)(classType);
+        // If the declared type is a protocol class or instance, skip
+        // the check. This has legitimate uses for mix-in classes.
+        if ((0, types_1.isInstantiableClass)(paramType) && types_1.ClassType.isProtocolClass(paramType)) {
+            return;
+        }
+        if ((0, types_1.isClassInstance)(paramType) && types_1.ClassType.isProtocolClass(paramType)) {
+            return;
+        }
+        // Don't enforce this for an overloaded method because the "self" param
+        // annotation can be used as a filter for the overload.
+        if (types_1.FunctionType.isOverloaded(functionType)) {
+            return;
+        }
+        if (!this._evaluator.assignType(paramType, expectedType)) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.clsSelfParamTypeMismatch().format({
+                name: paramInfo.name,
+                classType: this._evaluator.printType(expectedType, /* expandTypeAlias */ false),
+            }), paramInfo.typeAnnotation);
+        }
+    }
+    _validateYieldType(node, yieldType) {
+        let declaredReturnType;
+        let declaredYieldType;
+        const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
+        if (enclosingFunctionNode) {
+            const functionTypeResult = this._evaluator.getTypeOfFunction(enclosingFunctionNode);
+            if (functionTypeResult) {
+                (0, debug_1.assert)((0, types_1.isFunction)(functionTypeResult.functionType));
+                declaredReturnType = types_1.FunctionType.getSpecializedReturnType(functionTypeResult.functionType);
+                if (declaredReturnType) {
+                    declaredYieldType = (0, typeUtils_1.getGeneratorYieldType)(declaredReturnType, !!enclosingFunctionNode.isAsync);
+                }
+                if (declaredReturnType && !declaredYieldType && enclosingFunctionNode.returnTypeAnnotation) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, enclosingFunctionNode.isAsync
+                        ? localize_1.Localizer.Diagnostic.generatorAsyncReturnType()
+                        : localize_1.Localizer.Diagnostic.generatorSyncReturnType(), enclosingFunctionNode.returnTypeAnnotation);
+                }
+            }
+        }
+        if (this._evaluator.isNodeReachable(node, /* sourceNode */ undefined)) {
+            if (declaredReturnType && (0, types_1.isNever)(declaredReturnType)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noReturnContainsYield(), node);
+            }
+            else if (declaredYieldType) {
+                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                if (!this._evaluator.assignType(declaredYieldType, yieldType, diagAddendum)) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.yieldTypeMismatch().format({
+                        exprType: this._evaluator.printType(yieldType, /* expandTypeAlias */ false),
+                        yieldType: this._evaluator.printType(declaredYieldType, /* expandTypeAlias */ false),
+                    }) + diagAddendum.getString(), node.expression || node);
+                }
+            }
+        }
+    }
+    // Determines whether any of the except statements are unreachable because
+    // they are redundant.
+    _reportUnusedExceptStatements(node) {
+        let sawUnknownExceptionType = false;
+        const exceptionTypesSoFar = [];
+        node.exceptClauses.forEach((except) => {
+            if (sawUnknownExceptionType || except.isExceptGroup || !except.typeExpression) {
+                return;
+            }
+            const exceptionType = this._evaluator.getType(except.typeExpression);
+            if (!exceptionType || (0, types_1.isAnyOrUnknown)(exceptionType)) {
+                sawUnknownExceptionType = true;
+                return;
+            }
+            const typesOfThisExcept = [];
+            if ((0, types_1.isInstantiableClass)(exceptionType)) {
+                // If the exception type is a variable whose type could represent
+                // subclasses, the actual exception type is statically unknown.
+                if (exceptionType.includeSubclasses) {
+                    sawUnknownExceptionType = true;
+                }
+                typesOfThisExcept.push(exceptionType);
+            }
+            else if ((0, types_1.isClassInstance)(exceptionType)) {
+                const iterableType = this._evaluator.getTypeOfIterator(exceptionType, /* isAsync */ false, /* errorNode */ undefined) ||
+                    types_1.UnknownType.create();
+                (0, typeUtils_1.doForEachSubtype)(iterableType, (subtype) => {
+                    if ((0, types_1.isAnyOrUnknown)(subtype)) {
+                        sawUnknownExceptionType = true;
+                    }
+                    if ((0, types_1.isInstantiableClass)(subtype)) {
+                        // If the exception type is a variable whose type could represent
+                        // subclasses, the actual exception type is statically unknown.
+                        if (subtype.includeSubclasses) {
+                            sawUnknownExceptionType = true;
+                        }
+                        typesOfThisExcept.push(subtype);
+                    }
+                });
+            }
+            else {
+                sawUnknownExceptionType = true;
+            }
+            if (exceptionTypesSoFar.length > 0 && !sawUnknownExceptionType) {
+                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                let overriddenExceptionCount = 0;
+                typesOfThisExcept.forEach((thisExceptType) => {
+                    const subtype = exceptionTypesSoFar.find((previousExceptType) => {
+                        return (0, typeUtils_1.derivesFromClassRecursive)(thisExceptType, previousExceptType, /* ignoreUnknown */ true);
+                    });
+                    if (subtype) {
+                        diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.unreachableExcept().format({
+                            exceptionType: this._evaluator.printType((0, typeUtils_1.convertToInstance)(thisExceptType)),
+                            parentType: this._evaluator.printType((0, typeUtils_1.convertToInstance)(subtype)),
+                        }));
+                        overriddenExceptionCount++;
+                    }
+                });
+                // Were all of the exception types overridden?
+                if (typesOfThisExcept.length === overriddenExceptionCount) {
+                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unreachableExcept() + diagAddendum.getString(), except.typeExpression);
+                    this._evaluator.addUnusedCode(except, except.exceptSuite);
+                }
+            }
+            exceptionTypesSoFar.push(...typesOfThisExcept);
+        });
+    }
+    _reportDuplicateImports() {
+        const importStatements = (0, importStatementUtils_1.getTopLevelImports)(this._moduleNode);
+        const importModuleMap = new Map();
+        importStatements.orderedImports.forEach((importStatement) => {
+            if (importStatement.node.nodeType === 22 /* ImportFrom */) {
+                const symbolMap = new Map();
+                importStatement.node.imports.forEach((importFromAs) => {
+                    // Ignore duplicates if they're aliased.
+                    if (!importFromAs.alias) {
+                        const prevImport = symbolMap.get(importFromAs.name.value);
+                        if (prevImport) {
+                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportDuplicateImport, diagnosticRules_1.DiagnosticRule.reportDuplicateImport, localize_1.Localizer.Diagnostic.duplicateImport().format({ importName: importFromAs.name.value }), importFromAs.name);
+                        }
+                        else {
+                            symbolMap.set(importFromAs.name.value, importFromAs);
+                        }
+                    }
+                });
+            }
+            else if (importStatement.subnode) {
+                // Ignore duplicates if they're aliased.
+                if (!importStatement.subnode.alias) {
+                    const prevImport = importModuleMap.get(importStatement.moduleName);
+                    if (prevImport) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportDuplicateImport, diagnosticRules_1.DiagnosticRule.reportDuplicateImport, localize_1.Localizer.Diagnostic.duplicateImport().format({ importName: importStatement.moduleName }), importStatement.subnode);
+                    }
+                    else {
+                        importModuleMap.set(importStatement.moduleName, importStatement.subnode);
+                    }
+                }
+            }
+        });
+    }
+}
+exports.Checker = Checker;
+class MissingModuleSourceReporter extends parseTreeWalker_1.ParseTreeWalker {
+    constructor(_importResolver, _evaluator, _fileInfo) {
+        super();
+        this._importResolver = _importResolver;
+        this._evaluator = _evaluator;
+        this._fileInfo = _fileInfo;
+    }
+    static report(importResolver, evaluator, fileInfo, node) {
+        if (fileInfo.isStubFile) {
+            // Don't report this for stub files.
+            return;
+        }
+        new MissingModuleSourceReporter(importResolver, evaluator, fileInfo).walk(node);
+    }
+    visitNode(node) {
+        // Optimization. don't walk into expressions which can't
+        // have import statement as child nodes.
+        if ((0, parseNodes_1.isExpressionNode)(node)) {
+            return [];
+        }
+        return super.visitNode(node);
+    }
+    visitModule(node) {
+        const codeComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(node);
+        if (isPrintCodeComplexityEnabled) {
+            console.log(`Code complexity of module ${this._fileInfo.filePath} is ${codeComplexity.toString()}`);
+        }
+        if (codeComplexity > typeEvaluator_1.maxCodeComplexity) {
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.codeTooComplexToAnalyze(), { start: 0, length: 0 });
+            return false;
+        }
+        return true;
+    }
+    visitModuleName(node) {
+        const importResult = AnalyzerNodeInfo.getImportInfo(node);
+        (0, debug_1.assert)(importResult !== undefined);
+        this._addMissingModuleSourceDiagnosticIfNeeded(importResult, node);
+        return false;
+    }
+    visitImportFromAs(node) {
+        const decls = this._evaluator.getDeclarationsForNameNode(node.name);
+        if (!decls) {
+            return false;
+        }
+        for (const decl of decls) {
+            if (!(0, declaration_1.isAliasDeclaration)(decl) || !decl.submoduleFallback || decl.node !== node) {
+                // If it is not implicitly imported module, move to next.
+                continue;
+            }
+            const resolvedAlias = this._evaluator.resolveAliasDeclaration(decl, /* resolveLocalNames */ true);
+            if (!(resolvedAlias === null || resolvedAlias === void 0 ? void 0 : resolvedAlias.path) || !(0, sourceMapper_1.isStubFile)(resolvedAlias.path)) {
+                continue;
+            }
+            const importResult = this._getImportResult(node, resolvedAlias.path);
+            if (!importResult) {
+                continue;
+            }
+            this._addMissingModuleSourceDiagnosticIfNeeded(importResult, node.name);
+            break;
+        }
+        return false;
+    }
+    _getImportResult(node, filePath) {
+        const execEnv = this._importResolver.getConfigOption().findExecEnvironment(filePath);
+        const moduleNameNode = node.parent.module;
+        // Handle both absolute and relative imports.
+        const moduleName = moduleNameNode.leadingDots === 0
+            ? this._importResolver.getModuleNameForImport(filePath, execEnv).moduleName
+            : (0, importStatementUtils_1.getRelativeModuleName)(this._importResolver.fileSystem, this._fileInfo.filePath, filePath);
+        if (!moduleName) {
+            return undefined;
+        }
+        return this._importResolver.resolveImport(this._fileInfo.filePath, execEnv, (0, importResolver_1.createImportedModuleDescriptor)(moduleName));
+    }
+    _addMissingModuleSourceDiagnosticIfNeeded(importResult, node) {
+        if (importResult.isNativeLib ||
+            !importResult.isStubFile ||
+            importResult.importType === 0 /* BuiltIn */ ||
+            !importResult.nonStubImportResult ||
+            importResult.nonStubImportResult.isImportFound) {
+            return;
+        }
+        // Type stub found, but source is missing.
+        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingModuleSource, diagnosticRules_1.DiagnosticRule.reportMissingModuleSource, localize_1.Localizer.Diagnostic.importSourceResolveFailure().format({
+            importName: importResult.importName,
+        }), node);
+    }
+}
+//# sourceMappingURL=checker.js.map