@zzzen/pyright-internal 1.2.0-dev.20230709 → 1.2.0-dev.20230716

package/dist/analyzer/typeEvaluator.js

@@ -566,7 +566,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             case 31 /* List */:
             case 45 /* Set */: {
-                typeResult = getTypeOfListOrSet(node, inferenceContext);
+                typeResult = getTypeOfListOrSet(node, flags, inferenceContext);
                 break;
             }
             case 46 /* Slice */: {
@@ -586,7 +586,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 15 /* Dictionary */: {
-                typeResult = getTypeOfDictionary(node, inferenceContext);
+                typeResult = getTypeOfDictionary(node, flags, inferenceContext);
                 break;
             }
             case 30 /* Lambda */: {
@@ -1990,10 +1990,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiagAddendum) {
                     diagAddendum = expectedTypeDiagAddendum;
                 }
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAssignmentMismatch().format({
-                    sourceType: printType(type),
-                    destType: printType(declaredType),
-                }) + diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_c = (_b = diagAddendum.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : srcExpression) !== null && _c !== void 0 ? _c : nameNode);
+                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAssignmentMismatch().format(printSrcDestTypes(type, declaredType)) +
+                    diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_c = (_b = diagAddendum.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : srcExpression) !== null && _c !== void 0 ? _c : nameNode);
                 // Replace the assigned type with the (unnarrowed) declared type.
                 destType = declaredType;
             }
@@ -3681,6 +3679,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     types_1.ClassType.isSameGenericClass(memberInfo.classType, classType)) {
                     setSymbolAccessed(AnalyzerNodeInfo.getFileInfo(errorNode), memberInfo.symbol, errorNode);
                 }
+                // Special-case `__init_subclass` and `__class_getitem__` because
+                // these are always treated as class methods even if they're not
+                // decorated as such.
+                if (memberName === '__init_subclass__' || memberName === '__class_getitem__') {
+                    if ((0, types_1.isFunction)(type) && !types_1.FunctionType.isClassMethod(type)) {
+                        type = types_1.FunctionType.cloneWithNewFlags(type, type.details.flags | 2 /* ClassMethod */);
+                    }
+                }
             }
             const descriptorResult = applyDescriptorAccessMethod(type, memberInfo, classType, bindToType, isAccessedThroughObject, flags, errorNode, memberName, usage, diag);
             if (!descriptorResult) {
@@ -4212,7 +4218,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // We limit type narrowing for index expressions to built-in types that are
             // known to have symmetric __getitem__ and __setitem__ methods (i.e. the value
             // passed to __setitem__ is the same type as the value returned by __getitem__).
-            let baseTypeSupportsIndexNarrowing = true;
+            let baseTypeSupportsIndexNarrowing = !(0, types_1.isAny)(baseTypeResult.type);
             mapSubtypesExpandTypeVars(baseTypeResult.type, /* conditionFilter */ undefined, (subtype) => {
                 if (!(0, types_1.isClassInstance)(subtype) ||
                     !(types_1.ClassType.isBuiltIn(subtype) || types_1.ClassType.isTypedDictClass(subtype))) {
@@ -4971,14 +4977,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const getTypeArgTypeResult = (expr, argIndex) => {
             let typeResult;
             // If it's a custom __class_getitem__, none of the arguments should be
-            // treated as types. If it's an Annotated[a, b, c], only the first index
-            // should be treated as a type. The others can be regular (non-type) objects.
-            if ((options === null || options === void 0 ? void 0 : options.hasCustomClassGetItem) || ((options === null || options === void 0 ? void 0 : options.isAnnotatedClass) && argIndex > 0)) {
+            // treated as types.
+            if (options === null || options === void 0 ? void 0 : options.hasCustomClassGetItem) {
+                adjFlags =
+                    32 /* DisallowParamSpec */ |
+                        64 /* DisallowTypeVarTuple */ |
+                        2 /* DoNotSpecialize */ |
+                        131072 /* DisallowClassVar */;
                 typeResult = {
-                    ...getTypeOfExpression(expr, 32 /* DisallowParamSpec */ |
+                    ...getTypeOfExpression(expr, adjFlags),
+                    node: expr,
+                };
+            }
+            else if ((options === null || options === void 0 ? void 0 : options.isAnnotatedClass) && argIndex > 0) {
+                // If it's an Annotated[a, b, c], only the first index should be
+                // treated as a type.The others can be regular(non - type) objects.
+                adjFlags =
+                    32 /* DisallowParamSpec */ |
                         64 /* DisallowTypeVarTuple */ |
                         2 /* DoNotSpecialize */ |
-                        131072 /* DisallowClassVar */),
+                        131072 /* DisallowClassVar */;
+                if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(node))) {
+                    adjFlags |= 4 /* AllowForwardReferences */;
+                }
+                typeResult = {
+                    ...getTypeOfExpression(expr, adjFlags),
                     node: expr,
                 };
             }
@@ -5073,6 +5096,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeResult;
     }
     function getTypeOfTuple(node, flags, inferenceContext) {
+        var _a;
+        if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0 &&
+            ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* Argument */) {
+            // This is allowed inside of an index trailer, specifically
+            // to support Tuple[()], which is the documented way to annotate
+            // a zero-length tuple.
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.useTupleInstead());
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.tupleInAnnotation() + diag.getString(), node);
+        }
         if ((flags & 128 /* ExpectingInstantiableType */) !== 0 &&
             node.expressions.length === 0 &&
             !inferenceContext) {
@@ -5230,12 +5263,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfCall(node, flags, inferenceContext) {
         var _a;
         let baseTypeResult;
+        if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0 &&
+            node.leftExpression.nodeType === 38 /* Name */ &&
+            node.leftExpression.value === 'type') {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.useTypeInstead());
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeCallNotAllowed() + diag.getString(), node);
+        }
         // Handle immediate calls of lambdas specially.
         if (node.leftExpression.nodeType === 30 /* Lambda */) {
             baseTypeResult = getTypeOfLambdaForCall(node, inferenceContext);
         }
         else {
-            baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
+            baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */ | (flags & 4 /* AllowForwardReferences */));
         }
         const argList = node.arguments.map((arg) => {
             const functionArg = {
@@ -6163,19 +6203,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 case 6 /* OverloadedFunction */: {
                     // Handle the 'cast' call as a special case.
                     if (expandedSubtype.overloads[0].details.builtInName === 'cast' && argList.length === 2) {
-                        // Verify that the cast is necessary.
-                        const castToType = getTypeOfArgumentExpectingType(argList[0]).type;
-                        const castFromType = getTypeOfArgument(argList[1]).type;
-                        if (types_1.TypeBase.isInstantiable(castToType) && !(0, types_1.isUnknown)(castToType)) {
-                            if ((0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(castToType), castFromType, {
-                                ignorePseudoGeneric: true,
-                            })) {
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUnnecessaryCast, diagnosticRules_1.DiagnosticRule.reportUnnecessaryCast, localize_1.Localizer.Diagnostic.unnecessaryCast().format({
-                                    type: printType(castFromType),
-                                }), errorNode);
-                            }
-                        }
-                        return (0, typeUtils_1.convertToInstance)(castToType);
+                        return evaluateCastCall(argList, errorNode);
                     }
                     const functionResult = validateOverloadedFunctionArguments(errorNode, argList, { type: expandedSubtype, isIncomplete: callTypeResult.isIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext);
                     (0, collectionUtils_1.appendArray)(overloadsUsedForCall, functionResult.overloadsUsedForCall);
@@ -6435,6 +6463,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             overloadsUsedForCall,
         };
     }
+    // Evaluates the type of the "cast" call.
+    function evaluateCastCall(argList, errorNode) {
+        // Verify that the cast is necessary.
+        const castToType = getTypeOfArgumentExpectingType(argList[0]).type;
+        const castFromType = getTypeOfArgument(argList[1]).type;
+        if (types_1.TypeBase.isInstantiable(castToType) && !(0, types_1.isUnknown)(castToType)) {
+            if ((0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(castToType), castFromType, {
+                ignorePseudoGeneric: true,
+            })) {
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUnnecessaryCast, diagnosticRules_1.DiagnosticRule.reportUnnecessaryCast, localize_1.Localizer.Diagnostic.unnecessaryCast().format({
+                    type: printType(castFromType),
+                }), errorNode);
+            }
+        }
+        return (0, typeUtils_1.convertToInstance)(castToType);
+    }
     // Expands any unpacked tuples within an argument list.
     function expandArgList(argList) {
         var _a;
@@ -6530,8 +6574,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Does this function define the param spec, or is it an inner
                 // function nested within another function that defines the param
                 // spec? We need to handle these two cases differently.
-                if (varArgListParam.type.scopeId === typeResult.type.details.typeVarScopeId ||
-                    varArgListParam.type.scopeId === typeResult.type.details.constructorTypeVarScopeId) {
+                const paramSpecScopeId = varArgListParam.type.scopeId;
+                if (paramSpecScopeId === typeResult.type.details.typeVarScopeId ||
+                    paramSpecScopeId === typeResult.type.details.constructorTypeVarScopeId) {
                     paramSpecArgList = [];
                     paramSpecTarget = types_1.TypeVarType.cloneForParamSpecAccess(varArgListParam.type, /* access */ undefined);
                 }
@@ -6540,6 +6585,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        else if (typeResult.type.details.paramSpec) {
+            const paramSpecScopeId = typeResult.type.details.paramSpec.scopeId;
+            if (paramSpecScopeId === typeResult.type.details.typeVarScopeId ||
+                paramSpecScopeId === typeResult.type.details.constructorTypeVarScopeId) {
+                hasParamSpecArgsKwargs = true;
+                paramSpecArgList = [];
+                paramSpecTarget = types_1.TypeVarType.cloneForParamSpecAccess(typeResult.type.details.paramSpec, 
+                /* access */ undefined);
+            }
+        }
         // If there are keyword arguments present after a *args argument,
         // the keyword arguments may target one or more parameters that are positional.
         // In this case, we will limit the number of positional parameters so the
@@ -7028,27 +7083,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 trySetActive(argList[argIndex], paramDetails.params[paramInfoIndex].param);
                             }
                         }
+                        else if (paramSpecArgList) {
+                            paramSpecArgList.push(argList[argIndex]);
+                        }
                         else if (paramDetails.kwargsIndex !== undefined) {
-                            if (paramSpecArgList) {
-                                paramSpecArgList.push(argList[argIndex]);
-                            }
-                            else {
-                                const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
-                                validateArgTypeParams.push({
-                                    paramCategory: 2 /* KwargsDict */,
-                                    paramType,
-                                    requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
-                                    argument: argList[argIndex],
-                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
-                                    paramName: paramNameValue,
-                                });
-                                // Remember that this parameter has already received a value.
-                                paramMap.set(paramNameValue, {
-                                    argsNeeded: 1,
-                                    argsReceived: 1,
-                                    isPositionalOnly: false,
-                                });
-                            }
+                            const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
+                            validateArgTypeParams.push({
+                                paramCategory: 2 /* KwargsDict */,
+                                paramType,
+                                requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
+                                argument: argList[argIndex],
+                                errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
+                                paramName: paramNameValue,
+                            });
+                            // Remember that this parameter has already received a value.
+                            paramMap.set(paramNameValue, {
+                                argsNeeded: 1,
+                                argsReceived: 1,
+                                isPositionalOnly: false,
+                            });
                             (0, debug_1.assert)(paramDetails.params[paramDetails.kwargsIndex], 'paramDetails.kwargsIndex params entry is undefined');
                             trySetActive(argList[argIndex], paramDetails.params[paramDetails.kwargsIndex].param);
                         }
@@ -7058,15 +7111,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     else if (argList[argIndex].argumentCategory === 0 /* Simple */) {
-                        if (!isDiagnosticSuppressedForNode(errorNode)) {
-                            const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
-                                ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
-                                : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
-                                    expected: positionParamLimitIndex,
-                                }), argList[argIndex].valueExpression || errorNode);
+                        if (paramSpecArgList) {
+                            paramSpecArgList.push(argList[argIndex]);
+                        }
+                        else {
+                            if (!isDiagnosticSuppressedForNode(errorNode)) {
+                                const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                                    ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
+                                    : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                                        expected: positionParamLimitIndex,
+                                    }), argList[argIndex].valueExpression || errorNode);
+                            }
+                            reportedArgError = true;
                         }
-                        reportedArgError = true;
                     }
                     else if (argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
                         // Handle the case where a *args: P.args is passed as an argument to
@@ -7700,7 +7758,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return false;
         }
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
-        const srcTypeVarContext = new typeVarContext_1.TypeVarContext(paramSpecType.details.typeVarScopeId);
+        const srcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(paramSpecType));
         let reportedArgError = false;
         // Build a map of all named parameters.
         const paramMap = new Map();
@@ -8663,7 +8721,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return returnType;
     }
-    function getTypeOfDictionary(node, inferenceContext) {
+    function getTypeOfDictionary(node, flags, inferenceContext) {
+        var _a;
+        if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0 &&
+            ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* Argument */) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.useDictInstead());
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dictInAnnotation() + diag.getString(), node);
+        }
         // If the expected type is a union, analyze for each of the subtypes
         // to find one that matches.
         let effectiveExpectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
@@ -8823,7 +8888,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isIncomplete = false;
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
-            var _a, _b, _c;
+            var _a;
             let addUnknown = true;
             if (entryNode.nodeType === 17 /* DictionaryKeyEntry */) {
                 const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, 
@@ -8857,8 +8922,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     /* flags */ undefined, entryInferenceContext);
                 }
                 if (entryInferenceContext && !valueTypeResult.typeErrors) {
-                    valueTypeResult.type =
-                        (_a = inferTypeArgFromExpectedEntryType(entryInferenceContext, [valueTypeResult.type], !isValueTypeInvariant)) !== null && _a !== void 0 ? _a : valueTypeResult.type;
+                    const fromExpectedType = inferTypeArgFromExpectedEntryType(entryInferenceContext, [valueTypeResult.type], !isValueTypeInvariant);
+                    if (fromExpectedType) {
+                        valueTypeResult = { ...valueTypeResult, type: fromExpectedType };
+                    }
                 }
                 if (expectedDiagAddendum && valueTypeResult.expectedTypeDiagAddendum) {
                     expectedDiagAddendum.addAddendum(valueTypeResult.expectedTypeDiagAddendum);
@@ -8882,11 +8949,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 const entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(expectedType);
-                const unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, 
+                let unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, 
                 /* flags */ undefined, entryInferenceContext);
                 if (entryInferenceContext && !unexpandedTypeResult.typeErrors) {
-                    unexpandedTypeResult.type =
-                        (_b = inferTypeArgFromExpectedEntryType(entryInferenceContext, [unexpandedTypeResult.type], !isValueTypeInvariant)) !== null && _b !== void 0 ? _b : unexpandedTypeResult.type;
+                    const fromExpectedType = inferTypeArgFromExpectedEntryType(entryInferenceContext, [unexpandedTypeResult.type], !isValueTypeInvariant);
+                    if (fromExpectedType) {
+                        unexpandedTypeResult = { ...unexpandedTypeResult, type: fromExpectedType };
+                    }
                 }
                 if (unexpandedTypeResult.isIncomplete) {
                     isIncomplete = true;
@@ -8942,7 +9011,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // The result should be a tuple.
                 if ((0, types_1.isClassInstance)(dictEntryType) && (0, typeUtils_1.isTupleClass)(dictEntryType)) {
-                    const typeArgs = (_c = dictEntryType.tupleTypeArguments) === null || _c === void 0 ? void 0 : _c.map((t) => t.type);
+                    const typeArgs = (_a = dictEntryType.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.map((t) => t.type);
                     if (typeArgs && typeArgs.length === 2) {
                         if (forceStrictInference || index < maxEntriesToUseForInference) {
                             keyTypes.push({ node: entryNode, type: typeArgs[0] });
@@ -8961,7 +9030,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return isIncomplete;
     }
-    function getTypeOfListOrSet(node, inferenceContext) {
+    function getTypeOfListOrSet(node, flags, inferenceContext) {
+        var _a;
+        if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0 &&
+            node.nodeType === 31 /* List */ &&
+            ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* Argument */) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.useListInstead());
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.listInAnnotation() + diag.getString(), node);
+        }
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
         let effectiveExpectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
@@ -12039,6 +12116,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Note that the inferred type, once lazily computed, needs to wrap the
         // resulting type in an awaitable.
+        functionType.details.flags |= 1024 /* WrapReturnTypeInAwait */;
         awaitableFunctionType.details.flags |= 1024 /* WrapReturnTypeInAwait */;
         return awaitableFunctionType;
     }
@@ -12525,18 +12603,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* isPositiveTest */ false);
             }
         }
-        // Determine if the pre-narrowed subject type contains an object.
-        let subjectIsObject = false;
-        (0, typeUtils_1.doForEachSubtype)(makeTopLevelTypeVarsConcrete(subjectType), (subtype) => {
-            if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
-                subjectIsObject = true;
-            }
-        });
-        // Apply positive narrowing for the current case statement.
-        subjectType = (0, patternMatching_1.narrowTypeBasedOnPattern)(evaluatorInterface, subjectType, node.pattern, 
-        /* isPositiveTest */ true);
-        (0, patternMatching_1.assignTypeToPatternTargets)(evaluatorInterface, subjectType, !!subjectTypeResult.isIncomplete, subjectIsObject, node.pattern);
-        writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* None */);
+        const narrowedSubjectType = (0, patternMatching_1.assignTypeToPatternTargets)(evaluatorInterface, subjectType, !!subjectTypeResult.isIncomplete, node.pattern);
+        writeTypeCache(node, { type: narrowedSubjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForImportFrom(node) {
         if (isTypeCached(node)) {
@@ -14601,6 +14669,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let typedDecls = symbol.getTypedDeclarations();
         if (typedDecls.length === 0) {
+            // If the symbol has no type declaration but is assigned many times,
+            // treat it as though it has an explicit type annotation of "Unknown".
+            // This will avoid a pathological performance condition for unannotated
+            // code that reassigns the same variable hundreds of times. If the symbol
+            // effectively has an "Any" annotation, it won't be narrowed.
+            if (symbol.getDeclarations().length > maxDeclarationsToUseForInference) {
+                return { type: types_1.UnknownType.create() };
+            }
             // There was no declaration with a defined type.
             return { type: undefined };
         }
@@ -15571,10 +15647,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     destType.details.parameters.length <= 2) {
                     return true;
                 }
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
-                    sourceType: printType(srcType),
-                    destType: printType(destType),
-                }));
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 return false;
             }
         }
@@ -15673,10 +15746,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (assignType(destType, instantiableType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                         return true;
                     }
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
-                        sourceType: printType(srcType),
-                        destType: printType(destType),
-                    }));
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                     return false;
                 }
             }
@@ -15700,10 +15770,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* reportErrorsUsingObjType */ false)) {
                     return true;
                 }
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
-                    sourceType: printType(srcType),
-                    destType: printType(destType),
-                }));
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 return false;
             }
         }
@@ -15933,10 +16000,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.assignToNone());
             return false;
         }
-        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
-            sourceType: printType(srcType),
-            destType: printType(destType),
-        }));
+        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
         return false;
     }
     function assignFromUnionType(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
@@ -16078,10 +16142,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }, /* sortSubtypes */ true);
         if (isIncompatible) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
-                sourceType: printType(srcType),
-                destType: printType(destType),
-            }));
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
             return false;
         }
         return true;
@@ -16146,10 +16207,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
             if (isIncompatible) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
-                    sourceType: printType(srcType),
-                    destType: printType(destType),
-                }));
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 return false;
             }
             return true;
@@ -16229,10 +16287,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (!foundMatch) {
             if (diag && diagAddendum) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
-                    sourceType: printType(srcType),
-                    destType: printType(destType),
-                }));
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 diag.addAddendum(diagAddendum);
             }
             return false;
@@ -17663,6 +17718,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const flags = extraFlags ? evaluatorOptions.printTypeFlags | extraFlags : evaluatorOptions.printTypeFlags;
         return TypePrinter.printFunctionParts(type, flags, getFunctionEffectiveReturnType);
     }
+    // Prints two types and determines whether they need to be output in
+    // fully-qualified form for disambiguation.
+    function printSrcDestTypes(srcType, destType) {
+        const simpleSrcType = printType(srcType);
+        const simpleDestType = printType(destType);
+        if (simpleSrcType !== simpleDestType) {
+            return { sourceType: simpleSrcType, destType: simpleDestType };
+        }
+        const fullSrcType = printType(srcType, { useFullyQualifiedNames: true });
+        const fullDestType = printType(destType, { useFullyQualifiedNames: true });
+        if (fullSrcType !== fullDestType) {
+            return { sourceType: fullSrcType, destType: fullDestType };
+        }
+        return { sourceType: simpleSrcType, destType: simpleDestType };
+    }
     function printType(type, options) {
         let flags = evaluatorOptions.printTypeFlags;
         if (options === null || options === void 0 ? void 0 : options.expandTypeAlias) {
@@ -17683,6 +17753,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (options === null || options === void 0 ? void 0 : options.omitTypeArgumentsIfUnknown) {
             flags |= 2 /* OmitTypeArgumentsIfUnknown */;
         }
+        if (options === null || options === void 0 ? void 0 : options.useFullyQualifiedNames) {
+            flags |= 4096 /* UseFullyQualifiedNames */;
+        }
         return TypePrinter.printType(type, flags, getFunctionEffectiveReturnType);
     }
     // Calls back into the parser to parse the contents of a string literal.
@@ -17838,6 +17911,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         addDiagnostic,
         addDiagnosticForTextRange,
         printType,
+        printSrcDestTypes,
         printFunctionParts,
         getTypeCacheEntryCount,
         disposeEvaluator,