@zzzen/pyright-internal 1.2.0-dev.20230305 → 1.2.0-dev.20230312

package/dist/analyzer/typeEvaluator.js

@@ -253,6 +253,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let strClassType;
     let dictClassType;
     let typedDictClassType;
+    let typedDictPrivateClassType;
     let printExpressionSpaceCount = 0;
     let incompleteGenerationCount = 0;
     const returnTypeInferenceContextStack = [];
@@ -500,7 +501,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             intClassType = getBuiltInType(node, 'int');
             strClassType = getBuiltInType(node, 'str');
             dictClassType = getBuiltInType(node, 'dict');
-            typedDictClassType = getTypingType(node, '_TypedDict');
+            typedDictClassType = getTypingType(node, 'TypedDict');
+            typedDictPrivateClassType = getTypingType(node, '_TypedDict');
         }
     }
     function getTypeOfExpression(node, flags = 0 /* None */, inferenceContext) {
@@ -1842,7 +1844,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return isTypeHashable;
     }
     function getTypedDictClassType() {
-        return typedDictClassType;
+        return typedDictPrivateClassType;
     }
     function getTupleClassType() {
         return tupleClassType;
@@ -4405,7 +4407,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (param.details.isParamSpec && index < typeArgs.length) {
                 const typeArgType = typeArgs[index].type;
                 if (typeArgs[index].typeList) {
-                    const functionType = types_1.FunctionType.createInstantiable(65536 /* ParamSpecValue */);
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* ParamSpecValue */);
                     types_1.TypeBase.setSpecialForm(functionType);
                     typeArgs[index].typeList.forEach((paramType, paramIndex) => {
                         types_1.FunctionType.addParameter(functionType, {
@@ -4451,7 +4453,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 128 /* RetainLiteralsForTypeVar */);
                 }
                 else if ((0, typeUtils_1.isEllipsisType)(typeArgType)) {
-                    const functionType = types_1.FunctionType.createInstantiable(65536 /* ParamSpecValue */ | 32768 /* SkipArgsKwargsCompatibilityCheck */);
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* ParamSpecValue */ | 32768 /* SkipArgsKwargsCompatibilityCheck */);
                     types_1.TypeBase.setSpecialForm(functionType);
                     types_1.FunctionType.addDefaultParameters(functionType);
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext);
@@ -4538,7 +4540,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         type: printType(unexpandedSubtype),
                     }), node.baseExpression);
                     // Evaluate the index expressions as though they are type arguments for error-reporting.
-                    getTypeArgs(node, flags, /* isAnnotatedClass */ false, /* hasCustomClassGetItem */ false);
+                    getTypeArgs(node, flags);
                     return types_1.UnknownType.create();
                 }
             }
@@ -4593,7 +4595,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     types_1.ClassType.isPartiallyEvaluated(concreteSubtype);
                 const isFinalAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'Final');
                 const isClassVarAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'ClassVar');
-                let typeArgs = getTypeArgs(node, flags, isAnnotatedClass, hasCustomClassGetItem || !isGenericClass, isFinalAnnotation, isClassVarAnnotation);
+                // Inlined TypedDicts are supported only for 'dict' (and not for 'Dict').
+                const supportsTypedDictTypeArg = (0, types_1.isInstantiableClass)(concreteSubtype) &&
+                    types_1.ClassType.isBuiltIn(concreteSubtype, 'dict') &&
+                    !concreteSubtype.aliasName;
+                let typeArgs = getTypeArgs(node, flags, {
+                    isAnnotatedClass,
+                    hasCustomClassGetItem: hasCustomClassGetItem || !isGenericClass,
+                    isFinalAnnotation,
+                    isClassVarAnnotation,
+                    supportsTypedDictTypeArg,
+                });
                 if (!isAnnotatedClass) {
                     typeArgs = adjustTypeArgumentsForVariadicTypeVar(typeArgs, concreteSubtype.details.typeParameters, node);
                 }
@@ -4945,10 +4957,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isIncomplete: !!callResult.isTypeIncomplete,
         };
     }
-    function getTypeArgs(node, flags, isAnnotatedClass = false, hasCustomClassGetItem = false, isFinalAnnotation = false, isClassVarAnnotation = false) {
+    function getTypeArgs(node, flags, options) {
         const typeArgs = [];
         let adjFlags = flags;
-        if (isFinalAnnotation || isClassVarAnnotation) {
+        if ((options === null || options === void 0 ? void 0 : options.isFinalAnnotation) || (options === null || options === void 0 ? void 0 : options.isClassVarAnnotation)) {
             adjFlags |= 131072 /* DisallowClassVar */ | 16 /* DisallowFinal */;
         }
         else {
@@ -4956,7 +4968,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 32 /* DisallowParamSpec */ |
                 64 /* DisallowTypeVarTuple */ |
                 1048576 /* AllowRequired */);
-            if (!isAnnotatedClass) {
+            if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
                 adjFlags |= 131072 /* DisallowClassVar */ | 16 /* DisallowFinal */;
             }
             adjFlags |= 2097152 /* AllowUnpackedTupleOrTypeVarTuple */;
@@ -4967,7 +4979,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // 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 (hasCustomClassGetItem || (isAnnotatedClass && argIndex > 0)) {
+            if ((options === null || options === void 0 ? void 0 : options.hasCustomClassGetItem) || ((options === null || options === void 0 ? void 0 : options.isAnnotatedClass) && argIndex > 0)) {
                 typeResult = {
                     ...getTypeOfExpression(expr, 32 /* DisallowParamSpec */ |
                         64 /* DisallowTypeVarTuple */ |
@@ -4977,7 +4989,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 };
             }
             else {
-                typeResult = getTypeArg(expr, adjFlags);
+                typeResult = getTypeArg(expr, adjFlags, !!(options === null || options === void 0 ? void 0 : options.supportsTypedDictTypeArg) && argIndex === 0);
             }
             return typeResult;
         };
@@ -5016,7 +5028,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeArgs;
     }
-    function getTypeArg(node, flags) {
+    function getTypeArg(node, flags, supportsDictExpression) {
         let typeResult;
         let adjustedFlags = flags |
             128 /* ExpectingType */ |
@@ -5037,8 +5049,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Set the node's type so it isn't reevaluated later.
             setTypeForNode(node, types_1.UnknownType.create());
         }
+        else if (node.nodeType === 15 /* Dictionary */ && supportsDictExpression) {
+            const inlinedTypeDict = typedDictClassType && (0, types_1.isInstantiableClass)(typedDictClassType)
+                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, typedDictClassType)
+                : undefined;
+            const keyTypeFallback = strClassType && (0, types_1.isInstantiableClass)(strClassType) ? strClassType : types_1.UnknownType.create();
+            typeResult = {
+                type: keyTypeFallback,
+                inlinedTypeDict,
+                node,
+            };
+        }
         else {
             typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
+            if (node.nodeType === 15 /* Dictionary */) {
+                addError(localize_1.Localizer.Diagnostic.dictInAnnotation(), node);
+            }
             // "Protocol" is not allowed as a type argument.
             if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'Protocol')) {
                 addError(localize_1.Localizer.Diagnostic.protocolNotAllowedInTypeArgument(), node);
@@ -6023,7 +6049,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(constructorMethodType));
                 // Skip the unknown argument check if we've already checked for __init__.
-                const callResult = validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
+                let callResult;
+                if ((0, constructorTransform_1.hasConstructorTransform)(type)) {
+                    // Use speculative mode if we're going to later apply
+                    // a constructor transform. This allows us to use bidirectional
+                    // type inference for arguments in the transform.
+                    callResult = useSpeculativeMode(errorNode, () => {
+                        return validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
+                    });
+                }
+                else {
+                    callResult = validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
+                }
                 if (callResult.isTypeIncomplete) {
                     isTypeIncomplete = true;
                 }
@@ -6238,7 +6275,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), exprNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
-        const returnType = mapSubtypesExpandTypeVars(callTypeResult.type, 
+        let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, 
         /* conditionFilter */ undefined, (expandedSubtype, unexpandedSubtype) => {
             var _a, _b, _c, _d, _e, _f;
             switch (expandedSubtype.category) {
@@ -6257,6 +6294,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return expandedSubtype;
                 }
                 case 5 /* Function */: {
+                    if (types_1.TypeBase.isInstantiable(expandedSubtype)) {
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.callableNotInstantiable().format({
+                            type: printType(expandedSubtype),
+                        }), errorNode);
+                        argumentErrors = true;
+                        return undefined;
+                    }
                     // The stdlib collections/__init__.pyi stub file defines namedtuple
                     // as a function rather than a class, so we need to check for it here.
                     if (expandedSubtype.details.builtInName === 'namedtuple') {
@@ -6378,6 +6422,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                             (0, types_1.isNoneInstance)(subtype)) {
                                             return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
                                         }
+                                        else if ((0, types_1.isFunction)(subtype) && types_1.TypeBase.isInstance(subtype)) {
+                                            return types_1.FunctionType.cloneAsInstantiable(subtype);
+                                        }
                                         return types_1.AnyType.create();
                                     });
                                 }
@@ -6562,9 +6609,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return undefined;
         });
+        // If we ended up with a "Never" type because all code paths returned
+        // undefined due to argument errors, transform the result into an Unknown
+        // to avoid subsequent false positives.
+        if (argumentErrors && (0, types_1.isNever)(returnType) && !returnType.isNoReturn) {
+            returnType = types_1.UnknownType.create();
+        }
         return {
             argumentErrors,
-            returnType: (0, types_1.isNever)(returnType) && !returnType.isNoReturn ? undefined : returnType,
+            returnType,
             isTypeIncomplete,
             specializedInitSelfType,
             overloadsUsedForCall,
@@ -8278,8 +8331,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.addDefaultParameters(functionType);
             return functionType;
         }
-        if (node.nodeType === 52 /* Tuple */) {
-            node.expressions.forEach((paramExpr, index) => {
+        if (node.nodeType === 31 /* List */) {
+            node.entries.forEach((paramExpr, index) => {
                 const typeResult = getTypeOfExpressionExpectingType(paramExpr);
                 types_1.FunctionType.addParameter(functionType, {
                     category: 0 /* Simple */,
@@ -10548,6 +10601,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if ((0, types_1.isParamSpec)(typeArg.type)) {
                         addError(localize_1.Localizer.Diagnostic.paramSpecContext(), typeArg.node);
                     }
+                    else if ((0, types_1.isUnpackedVariadicTypeVar)(typeArg.type)) {
+                        addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), typeArg.node);
+                    }
+                    else if ((0, types_1.isUnpackedClass)(typeArg.type)) {
+                        addError(localize_1.Localizer.Diagnostic.unpackedArgInTypeArgument(), typeArg.node);
+                    }
                 }
             });
         }
@@ -11296,7 +11355,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     argType = (0, types_1.removeUnbound)(argType);
                 }
                 if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
-                    if ((0, types_1.isClass)(argType) && types_1.TypeBase.isInstance(argType) && types_1.ClassType.isBuiltIn(argType, 'type')) {
+                    if ((0, typeUtils_1.isMetaclassInstance)(argType)) {
+                        (0, debug_1.assert)((0, types_1.isClassInstance)(argType));
                         argType =
                             argType.typeArguments && argType.typeArguments.length > 0
                                 ? argType.typeArguments[0]
@@ -11883,6 +11943,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     decoratorCallType.details.builtInName === 'dataclass_transform') {
                     originalClassType.details.classDataClassTransform = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                 }
+                else if (decoratorCallType.details.name === 'deprecated') {
+                    originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                    return inputClassType;
+                }
             }
             if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
                 if (decoratorCallType.overloads.length > 0 &&
@@ -11912,6 +11976,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // dependency between builtins, typing and _typeshed stubs.
                 return inputClassType;
             }
+            if (decoratorType.details.builtInName === 'deprecated') {
+                originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                return inputClassType;
+            }
             if (decoratorType.details.builtInName === 'runtime_checkable') {
                 originalClassType.details.flags |= 32768 /* RuntimeCheckable */;
                 // Don't call getTypeOfDecorator for runtime_checkable. It appears
@@ -12704,6 +12772,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     undecoratedType.details.decoratorDataClassBehaviors = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                     return inputFunctionType;
                 }
+                if (decoratorCallType.details.name === 'deprecated') {
+                    undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                    return inputFunctionType;
+                }
             }
             if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
                 if (decoratorCallType.overloads.length > 0 &&
@@ -12719,6 +12791,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (decoratorType.details.builtInName === 'abstractmethod') {
                 return inputFunctionType;
             }
+            if (decoratorType.details.builtInName === 'deprecated') {
+                undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                return inputFunctionType;
+            }
             // Handle property setters and deleters.
             if (decoratorNode.expression.nodeType === 35 /* MemberAccess */) {
                 const baseType = getTypeOfExpression(decoratorNode.expression.leftExpression, evaluatorFlags | 2 /* DoNotSpecialize */).type;
@@ -12828,7 +12904,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         getTypeOfFunction(decl.node);
                     }
                 }
-                const overloadedTypes = [];
+                let overloadedTypes = [];
                 // Look at the previous declaration's type.
                 const prevDecl = decls[declIndex - 1];
                 if (prevDecl.type === 5 /* Function */) {
@@ -12850,6 +12926,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (overloadedTypes.length === 1) {
                     return overloadedTypes[0];
                 }
+                // Apply the implementation's docstring to any overloads that don't
+                // have their own docstrings.
+                const implementation = overloadedTypes.find((signature) => !types_1.FunctionType.isOverloaded(signature));
+                if (implementation === null || implementation === void 0 ? void 0 : implementation.details.docString) {
+                    overloadedTypes = overloadedTypes.map((overload) => {
+                        if (types_1.FunctionType.isOverloaded(overload) && !overload.details.docString) {
+                            return types_1.FunctionType.cloneWithDocString(overload, implementation.details.docString);
+                        }
+                        return overload;
+                    });
+                }
                 // Create a new overloaded type that copies the contents of the previous
                 // one and adds a new function.
                 const newOverload = types_1.OverloadedFunctionType.create(overloadedTypes);
@@ -14063,7 +14150,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (firstNonDefaultParam >= 0) {
                 minTypeArgCount = firstNonDefaultParam;
             }
-            if (typeArgCount > typeParameters.length) {
+            // Classes that accept inlined type dict type args allow only one.
+            if (typeArgs[0].inlinedTypeDict) {
+                if (typeArgs.length > 1) {
+                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
+                        name: classType.aliasName || classType.details.name,
+                        expected: 1,
+                        received: typeArgCount,
+                    }), typeArgs[1].node);
+                }
+                return { type: typeArgs[0].inlinedTypeDict };
+            }
+            else if (typeArgCount > typeParameters.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (typeParameters.length === 0) {
@@ -14147,7 +14245,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (typeArgs && index < typeArgs.length) {
                 if (typeParam.details.isParamSpec) {
                     const typeArg = typeArgs[index];
-                    const functionType = types_1.FunctionType.createInstantiable(65536 /* ParamSpecValue */);
+                    const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* ParamSpecValue */);
                     types_1.TypeBase.setSpecialForm(functionType);
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         types_1.FunctionType.addDefaultParameters(functionType);
@@ -14333,7 +14431,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const scopeTypeHonorsCodeFlow = scopeType !== 1 /* Function */ && scopeType !== 0 /* ListComprehension */;
         if (symbolWithScope && honorCodeFlow && scopeTypeHonorsCodeFlow) {
             // Filter the declarations based on flow reachability.
-            const reachableDecls = symbolWithScope.symbol.getDeclarations().filter((decl) => {
+            const reachableDecl = symbolWithScope.symbol.getDeclarations().find((decl) => {
                 if (decl.type !== 8 /* Alias */ && decl.type !== 0 /* Intrinsic */) {
                     // Is the declaration in the same execution scope as the "usageNode" node?
                     const usageScope = ParseTreeUtils.getExecutionScopeNode(node);
@@ -14361,7 +14459,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // If none of the declarations are reachable from the current node,
             // search for the symbol in outer scopes.
-            if (reachableDecls.length === 0) {
+            if (!reachableDecl) {
                 if (symbolWithScope.scope.type !== 1 /* Function */) {
                     let nextScopeToSearch = symbolWithScope.scope.parent;
                     const isOutsideCallerModule = symbolWithScope.isOutsideCallerModule || symbolWithScope.scope.type === 3 /* Module */;
@@ -14887,7 +14985,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeVar;
     }
     function getInferredTypeOfDeclaration(symbol, decl) {
-        var _a, _b;
+        var _a, _b, _c;
         const resolvedDecl = resolveAliasDeclaration(decl, 
         /* resolveLocalNames */ true, 
         /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile);
@@ -14903,7 +15001,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     moduleType.fields = lookupResults.symbolTable;
                     moduleType.docString = lookupResults.docString;
                 }
-                else {
+                else if (!loaderActions.implicitImports) {
                     return evaluatorOptions.evaluateUnknownImportsAsAny ? types_1.AnyType.create() : types_1.UnknownType.create();
                 }
             }
@@ -14979,17 +15077,34 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         isUnambiguousType = true;
                     }
                 }
+                // Special-case constants, which are treated as unambiguous.
                 if (isFinalVariableDeclaration(resolvedDecl) || resolvedDecl.isConstant) {
                     isUnambiguousType = true;
                 }
+                // Special-case calls to certain built-in type functions.
+                if (((_a = resolvedDecl.inferredTypeSource) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
+                    const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 2 /* DoNotSpecialize */);
+                    const callType = baseTypeResult.type;
+                    if ((0, types_1.isInstantiableClass)(callType) &&
+                        types_1.ClassType.isBuiltIn(callType, [
+                            'TypeVar',
+                            'ParamSpec',
+                            'TypeVarTuple',
+                            'TypedDict',
+                            'NamedTuple',
+                            'NewType',
+                        ])) {
+                        isUnambiguousType = true;
+                    }
+                }
             }
         }
         // If the resolved declaration had no defined type, use the
         // inferred type for this node.
         if (resolvedDecl.type === 2 /* Parameter */) {
-            return (_a = evaluateTypeForSubnode(resolvedDecl.node.name, () => {
+            return (_b = evaluateTypeForSubnode(resolvedDecl.node.name, () => {
                 evaluateTypeOfParameter(resolvedDecl.node);
-            })) === null || _a === void 0 ? void 0 : _a.type;
+            })) === null || _b === void 0 ? void 0 : _b.type;
         }
         if (resolvedDecl.type === 1 /* Variable */ && resolvedDecl.inferredTypeSource) {
             const isTypeAlias = isExplicitTypeAliasDeclaration(resolvedDecl) || isPossibleTypeAliasOrTypedDict(resolvedDecl);
@@ -14998,9 +15113,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const typeSource = isTypeAlias && resolvedDecl.inferredTypeSource.parent
                 ? resolvedDecl.inferredTypeSource.parent
                 : resolvedDecl.inferredTypeSource;
-            let inferredType = (_b = evaluateTypeForSubnode(resolvedDecl.node, () => {
+            let inferredType = (_c = evaluateTypeForSubnode(resolvedDecl.node, () => {
                 evaluateTypesForStatement(typeSource);
-            })) === null || _b === void 0 ? void 0 : _b.type;
+            })) === null || _c === void 0 ? void 0 : _c.type;
             if (inferredType && resolvedDecl.node.nodeType === 38 /* Name */) {
                 // See if this is an enum member. If so, we need to handle it as a special case.
                 const enumMemberType = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, resolvedDecl.node, () => {
@@ -15114,18 +15229,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
         var _a, _b;
-        // Look in the cache to see if we've computed this already.
-        let cacheEntries = effectiveTypeCache.get(symbol.id);
-        const usageNodeId = usageNode ? usageNode.id : undefined;
-        const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
-        if (cacheEntries) {
-            const result = cacheEntries.get(effectiveTypeCacheKey);
-            if (result) {
-                if (!result.isIncomplete) {
-                    return result;
-                }
-            }
-        }
         let declaredTypeInfo;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
@@ -15150,10 +15253,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     includesIllegalTypeAliasDecl: !typedDecls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
                     isRecursiveDefinition: !declaredType,
                 };
-                addToEffectiveTypeCache(result);
                 return result;
             }
         }
+        // Look in the inferred type cache to see if we've computed this already.
+        let cacheEntries = effectiveTypeCache.get(symbol.id);
+        const usageNodeId = usageNode ? usageNode.id : undefined;
+        const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
+        if (cacheEntries) {
+            const result = cacheEntries.get(effectiveTypeCacheKey);
+            if (result) {
+                if (!result.isIncomplete) {
+                    return result;
+                }
+            }
+        }
         // Infer the type.
         const typesToCombine = [];
         const decls = symbol.getDeclarations();