@zzzen/pyright-internal 1.2.0-dev.20241020 → 1.2.0-dev.20241103

package/dist/analyzer/typeEvaluator.js

@@ -206,6 +206,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let strClass;
     let dictClass;
     let moduleTypeClass;
+    let typedDictClass;
     let typedDictPrivateClass;
     let supportsKeysAndGetItemClass;
     let mappingClass;
@@ -500,6 +501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             strClass = getBuiltInType(node, 'str');
             dictClass = getBuiltInType(node, 'dict');
             moduleTypeClass = getTypingType(node, 'ModuleType');
+            typedDictClass = getTypingType(node, 'TypedDict');
             typedDictPrivateClass = getTypingType(node, '_TypedDict');
             awaitableClass = getTypingType(node, 'Awaitable');
             mappingClass = getTypingType(node, 'Mapping');
@@ -2022,7 +2024,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // Handle the case where the type is synthesized (used for
                         // dataclasses).
                         if (synthesizedType) {
-                            isObjectHashable = !(0, typeUtils_1.isNoneInstance)(synthesizedType);
+                            isObjectHashable = !(0, typeUtils_1.isNoneInstance)(synthesizedType.type);
                         }
                         else {
                             // Assume that if '__hash__' is declared as a variable, it is
@@ -2380,7 +2382,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (classTypeResults && (0, types_1.isInstantiableClass)(classTypeResults.classType)) {
                     enclosingClass = classTypeResults.classType;
                     if ((0, types_1.isClassInstance)(baseType)) {
-                        if (types_1.ClassType.isSameGenericClass(baseType, classTypeResults.classType)) {
+                        if (types_1.ClassType.isSameGenericClass(types_1.ClassType.cloneAsInstantiable(baseType), classTypeResults.classType)) {
                             assignTypeToMemberVariable(target, typeResult, /* isInstanceMember */ true, srcExpr);
                         }
                     }
@@ -3828,7 +3830,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     else {
                         // Is this an attempt to delete or overwrite an enum member?
                         if ((0, types_1.isClassInstance)(enumMemberResult.type) &&
-                            types_1.ClassType.isSameGenericClass(enumMemberResult.type, baseType) &&
+                            types_1.ClassType.isSameGenericClass(enumMemberResult.type, types_1.ClassType.cloneAsInstance(baseType)) &&
                             enumMemberResult.type.priv.literalValue !== undefined) {
                             const diagMessage = usage.method === 'set' ? localize_1.LocMessage.enumMemberSet() : localize_1.LocMessage.enumMemberDelete();
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue, diagMessage.format({ name: memberName }) + diag.getString(), node.d.member, (_c = diag.getEffectiveTextRange()) !== null && _c !== void 0 ? _c : node.d.member);
@@ -4107,7 +4109,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const containingClassType = (_a = getTypeOfClass(containingClass)) === null || _a === void 0 ? void 0 : _a.classType;
                 if (containingClassType &&
                     (0, types_1.isInstantiableClass)(containingClassType) &&
-                    types_1.ClassType.isSameGenericClass(containingClassType, classType)) {
+                    types_1.ClassType.isSameGenericClass(isAccessedThroughObject ? types_1.ClassType.cloneAsInstance(containingClassType) : containingClassType, classType)) {
                     type = (_b = getDeclaredTypeOfSymbol(memberInfo.symbol)) === null || _b === void 0 ? void 0 : _b.type;
                     if (type && (0, types_1.isInstantiableClass)(memberInfo.classType)) {
                         type = (0, typeUtils_1.partiallySpecializeType)(type, memberInfo.classType, 
@@ -4165,7 +4167,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Mark the member accessed if it's not coming from a parent class.
             if (errorNode &&
                 (0, types_1.isInstantiableClass)(memberInfo.classType) &&
-                types_1.ClassType.isSameGenericClass(memberInfo.classType, classType)) {
+                types_1.ClassType.isSameGenericClass(memberInfo.classType, isAccessedThroughObject ? types_1.ClassType.cloneAsInstantiable(classType) : classType)) {
                 setSymbolAccessed(AnalyzerNodeInfo.getFileInfo(errorNode), memberInfo.symbol, errorNode);
             }
             // Special-case `__init_subclass` and `__class_getitem__` because
@@ -4521,8 +4523,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isAsymmetric = false;
         }
         else {
-            const getterType = getEffectiveTypeOfSymbol(getterSymbolResult.symbol);
+            let getterType = getEffectiveTypeOfSymbol(getterSymbolResult.symbol);
             const setterType = getEffectiveTypeOfSymbol(setterSymbolResult.symbol);
+            // If this is an overload, find the appropriate overload.
+            if ((0, types_1.isOverloaded)(getterType)) {
+                const getOverloads = types_1.OverloadedType.getOverloads(getterType).filter((overload) => {
+                    if (overload.shared.parameters.length < 2) {
+                        return false;
+                    }
+                    const param1Type = types_1.FunctionType.getParamType(overload, 1);
+                    return !(0, typeUtils_1.isNoneInstance)(param1Type);
+                });
+                if (getOverloads.length === 1) {
+                    getterType = getOverloads[0];
+                }
+                else {
+                    isAsymmetric = true;
+                }
+            }
+            // If this is an overload, find the appropriate overload.
+            if ((0, types_1.isOverloaded)(setterType)) {
+                isAsymmetric = true;
+            }
             // If either the setter or getter is an overload (or some other non-function type),
             // conservatively assume that it's not asymmetric.
             if ((0, types_1.isFunction)(getterType) && (0, types_1.isFunction)(setterType)) {
@@ -5195,11 +5217,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     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');
+                // This feature is currently experimental.
+                const supportsTypedDictTypeArg = AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures &&
+                    types_1.ClassType.isBuiltIn(concreteSubtype, 'TypedDict');
                 let typeArgs = getTypeArgs(node, flags, {
                     isAnnotatedClass,
                     hasCustomClassGetItem: hasCustomClassGetItem || !isGenericClass,
                     isFinalAnnotation,
                     isClassVarAnnotation,
+                    supportsTypedDictTypeArg,
                 });
                 if (!isAnnotatedClass) {
                     typeArgs = adjustTypeArgsForTypeVarTuple(typeArgs, concreteSubtype.shared.typeParams, node);
@@ -5586,7 +5612,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 };
             }
             else {
-                typeResult = getTypeArg(expr, adjFlags);
+                typeResult = getTypeArg(expr, adjFlags, !!(options === null || options === void 0 ? void 0 : options.supportsTypedDictTypeArg) && argIndex === 0);
             }
             return typeResult;
         };
@@ -5664,7 +5690,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
-    function getTypeArg(node, flags) {
+    function getTypeArg(node, flags, supportsDictExpression) {
         let typeResult;
         let adjustedFlags = flags | 128 /* EvalFlags.InstantiableType */ | 1 /* EvalFlags.ConvertEllipsisToAny */ | 8 /* EvalFlags.StrLiteralAsType */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -5682,6 +5708,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Set the node's type so it isn't reevaluated later.
             setTypeResultForNode(node, { type: types_1.UnknownType.create() });
         }
+        else if (node.nodeType === 18 /* ParseNodeType.Dictionary */ && supportsDictExpression) {
+            const inlinedTypeDict = typedDictClass && (0, types_1.isInstantiableClass)(typedDictClass)
+                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, typedDictClass)
+                : undefined;
+            const keyTypeFallback = strClass && (0, types_1.isInstantiableClass)(strClass) ? strClass : types_1.UnknownType.create();
+            typeResult = {
+                type: keyTypeFallback,
+                inlinedTypeDict,
+                node,
+            };
+        }
         else {
             typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
             if (node.nodeType === 18 /* ParseNodeType.Dictionary */) {
@@ -6192,7 +6229,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (bindToType &&
                 types_1.ClassType.isProtocolClass(bindToType) &&
                 effectiveTargetClass &&
-                !types_1.ClassType.isSameGenericClass(bindToType, effectiveTargetClass)) {
+                !types_1.ClassType.isSameGenericClass(types_1.TypeBase.isInstance(bindToType) ? types_1.ClassType.cloneAsInstantiable(bindToType) : bindToType, effectiveTargetClass)) {
                 isProtocolClass = true;
                 effectiveTargetClass = undefined;
             }
@@ -6248,7 +6285,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // class.
             if (bindToType) {
                 let nextBaseClassType;
-                if (types_1.ClassType.isSameGenericClass(bindToType, concreteTargetClassType)) {
+                if (types_1.ClassType.isSameGenericClass(types_1.TypeBase.isInstance(bindToType) ? types_1.ClassType.cloneAsInstantiable(bindToType) : bindToType, concreteTargetClassType)) {
                     if (bindToType.shared.baseClasses.length > 0) {
                         nextBaseClassType = bindToType.shared.baseClasses[0];
                     }
@@ -7310,13 +7347,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Build a map of parameters by name.
         const paramMap = new Map();
         paramDetails.params.forEach((paramInfo) => {
+            var _a, _b;
             (0, debug_1.assert)(paramInfo !== undefined, 'paramInfo is undefined for param name map');
             const param = paramInfo.param;
             if (param.name && param.category === 0 /* ParamCategory.Simple */ && paramInfo.kind !== parameterUtils_1.ParamKind.Positional) {
-                paramMap.set(param.name, {
-                    argsNeeded: param.category === 0 /* ParamCategory.Simple */ && !paramInfo.defaultType ? 1 : 0,
-                    argsReceived: 0,
-                });
+                let argsNeeded = (_b = (_a = paramMap.get(param.name)) === null || _a === void 0 ? void 0 : _a.argsNeeded) !== null && _b !== void 0 ? _b : 0;
+                if (param.category === 0 /* ParamCategory.Simple */ && !paramInfo.defaultType) {
+                    argsNeeded += 1;
+                }
+                paramMap.set(param.name, { argsNeeded, argsReceived: 0 });
             }
         });
         let positionalOnlyLimitIndex = paramDetails.positionOnlyParamCount;
@@ -8369,11 +8408,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (paramSpec) {
                 if (argParam.argument.argCategory === 1 /* ArgCategory.UnpackedList */) {
                     if ((0, parameterUtils_1.isParamSpecArgs)(paramSpec, argResult.argType)) {
+                        if (sawParamSpecArgs) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsKwargsDuplicate().format({ type: printType(paramSpec) }), argParam.errorNode);
+                        }
                         sawParamSpecArgs = true;
                     }
                 }
                 if (argParam.argument.argCategory === 2 /* ArgCategory.UnpackedDictionary */) {
                     if ((0, parameterUtils_1.isParamSpecKwargs)(paramSpec, argResult.argType)) {
+                        if (sawParamSpecKwargs) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsKwargsDuplicate().format({ type: printType(paramSpec) }), argParam.errorNode);
+                        }
                         sawParamSpecKwargs = true;
                     }
                 }
@@ -9467,7 +9512,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, typeUtils_1.isNoneInstance)(subtype)) {
                 if (objectClass && (0, types_1.isInstantiableClass)(objectClass)) {
                     // Use 'object' for 'None'.
-                    return handleSubtype((0, typeUtils_1.convertToInstance)(objectClass));
+                    return handleSubtype(types_1.ClassType.cloneAsInstance(objectClass));
                 }
             }
             if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
@@ -12117,8 +12162,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     if (protocolTypeParams) {
                                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.duplicateGenericAndProtocolBase(), arg.d.valueExpr);
                                     }
-                                    genericTypeParams = [];
-                                    (0, typeUtils_1.addTypeVarsToListIfUnique)(genericTypeParams, (0, typeUtils_1.getTypeVarArgsRecursive)(argType));
+                                    genericTypeParams = buildTypeParamsFromTypeArgs(argType);
                                 }
                             }
                         }
@@ -12129,8 +12173,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 if (genericTypeParams) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.duplicateGenericAndProtocolBase(), arg.d.valueExpr);
                                 }
-                                protocolTypeParams = [];
-                                (0, typeUtils_1.addTypeVarsToListIfUnique)(protocolTypeParams, (0, typeUtils_1.getTypeVarArgsRecursive)(argType));
+                                protocolTypeParams = buildTypeParamsFromTypeArgs(argType);
                                 if (node.d.typeParams && protocolTypeParams.length > 0) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.protocolBaseClassWithTypeArgs(), arg.d.valueExpr);
                                     protocolTypeParams = [];
@@ -12479,6 +12522,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return { classType, decoratedType };
         });
     }
+    function buildTypeParamsFromTypeArgs(classType) {
+        var _a;
+        const typeParams = [];
+        const typeArgs = (_a = classType.priv.typeArgs) !== null && _a !== void 0 ? _a : [];
+        typeArgs.forEach((typeArg, index) => {
+            if ((0, types_1.isTypeVar)(typeArg)) {
+                typeParams.push(typeArg);
+                return;
+            }
+            // Synthesize a dummy type parameter.
+            const typeVar = types_1.TypeVarType.createInstance(`__P${index}`);
+            typeVar.shared.isSynthesized = true;
+            typeParams.push(typeVar);
+        });
+        return typeParams;
+    }
     // Determines whether the type parameters has a default that refers to another
     // type parameter. If so, validates that it is in the list of "live" type
     // parameters and updates the scope of the type parameter referred to in the
@@ -13610,6 +13669,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 writeTypeCache(node.d.suite, { type: inferredReturnType, isIncomplete }, 0 /* EvalFlags.None */);
             }
+            catch (err) {
+                // Attempt to handle a stack overflow without crashing. In rare
+                // cases, we can get very deep stacks when inferring return types
+                // within untyped code.
+                if ((err === null || err === void 0 ? void 0 : err.message) === 'Maximum call stack size exceeded') {
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                    console.error(`Overflowed stack when inferring return type for function: ${node.d.name.d.value} in file ${fileInfo.fileUri.toUserVisibleString()}`);
+                    return;
+                }
+                throw err;
+            }
             finally {
                 functionRecursionMap.delete(node.id);
             }
@@ -14620,7 +14690,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 case 'TypedDict': {
                     if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typedDictNotAllowed(), errorNode);
+                        const isInlinedTypedDict = AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures &&
+                            !!typeArgs;
+                        if (!isInlinedTypedDict) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typedDictNotAllowed(), errorNode);
+                        }
                     }
                     isValidTypeForm = false;
                     break;
@@ -14736,7 +14810,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (firstDefaultParamIndex >= 0) {
                 minTypeArgCount = firstDefaultParamIndex;
             }
-            if (typeArgCount > typeParams.length) {
+            // Classes that accept inlined type dict type args allow only one.
+            if (typeArgs.length > 0 && typeArgs[0].inlinedTypeDict) {
+                if (typeArgs.length > 1) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
+                        name: classType.priv.aliasName || classType.shared.name,
+                        expected: 1,
+                        received: typeArgCount,
+                    }), typeArgs[1].node);
+                }
+                return { type: typeArgs[0].inlinedTypeDict };
+            }
+            else if (typeArgCount > typeParams.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     if (typeParams.length === 0) {
                         isValidTypeForm = false;
@@ -15088,15 +15173,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Filter the declarations based on flow reachability.
             const reachableDecl = symbolWithScope.symbol.getDeclarations().find((decl) => {
                 if (decl.type !== 8 /* DeclarationType.Alias */ && decl.type !== 0 /* DeclarationType.Intrinsic */) {
-                    // Is the declaration in the same execution scope as the "usageNode" node?
-                    const usageScope = ParseTreeUtils.getExecutionScopeNode(node);
+                    // Determine if the declaration is in the same execution scope as the "usageNode" node.
+                    let usageScopeNode = ParseTreeUtils.getExecutionScopeNode(node);
                     const declNode = decl.type === 6 /* DeclarationType.Class */ ||
                         decl.type === 5 /* DeclarationType.Function */ ||
                         decl.type === 4 /* DeclarationType.TypeAlias */
                         ? decl.node.d.name
                         : decl.node;
-                    const declScope = ParseTreeUtils.getExecutionScopeNode(declNode);
-                    if (usageScope === declScope) {
+                    const declScopeNode = ParseTreeUtils.getExecutionScopeNode(declNode);
+                    // If this is a type parameter scope, it will be a proxy for its
+                    // containing scope, so we need to use that instead.
+                    const usageScope = AnalyzerNodeInfo.getScope(usageScopeNode);
+                    if (usageScope === null || usageScope === void 0 ? void 0 : usageScope.proxy) {
+                        const typeParamScope = AnalyzerNodeInfo.getScope(usageScopeNode);
+                        if (!(typeParamScope === null || typeParamScope === void 0 ? void 0 : typeParamScope.symbolTable.has(name)) && usageScopeNode.parent) {
+                            usageScopeNode = ParseTreeUtils.getExecutionScopeNode(usageScopeNode.parent);
+                        }
+                    }
+                    if (usageScopeNode === declScopeNode) {
                         if (!isFlowPathBetweenNodes(declNode, node)) {
                             // If there was no control flow path from the usage back
                             // to the source, see if the usage node is reachable by
@@ -15303,7 +15397,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // dictionary expression where those keys are associated with a known TypedDict.
     function getDeclInfoForStringNode(node) {
         var _a;
-        const declarations = [];
+        const decls = [];
+        const synthesizedTypes = [];
         const expectedType = (_a = getExpectedType(node)) === null || _a === void 0 ? void 0 : _a.type;
         if (expectedType) {
             (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
@@ -15317,13 +15412,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (entry) {
                         const symbol = (_b = (0, typeUtils_1.lookUpObjectMember)(subtype, node.d.value)) === null || _b === void 0 ? void 0 : _b.symbol;
                         if (symbol) {
-                            (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
+                            (0, collectionUtils_1.appendArray)(decls, symbol.getDeclarations());
+                            const synthTypeInfo = symbol.getSynthesizedType();
+                            if (synthTypeInfo) {
+                                synthesizedTypes.push(synthTypeInfo);
+                            }
                         }
                     }
                 }
             });
         }
-        return declarations.length === 0 ? undefined : { decls: declarations, synthesizedTypes: [] };
+        return decls.length === 0 ? undefined : { decls, synthesizedTypes };
     }
     function getAliasFromImport(node) {
         if (node.parent &&
@@ -15339,7 +15438,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (skipUnreachableCode && AnalyzerNodeInfo.isCodeUnreachable(node)) {
             return undefined;
         }
-        const declarations = [];
+        const decls = [];
         const synthesizedTypes = [];
         // If the node is part of a "from X import Y as Z" statement and the node
         // is the "Y" (non-aliased) name, we need to look up the alias symbol
@@ -15356,7 +15455,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const declsForThisImport = symbolInScope.symbol.getDeclarations().filter((decl) => {
                         return decl.type === 8 /* DeclarationType.Alias */ && decl.node === node.parent;
                     });
-                    (0, collectionUtils_1.appendArray)(declarations, (0, declarationUtils_1.getDeclarationsWithUsesLocalNameRemoved)(declsForThisImport));
+                    (0, collectionUtils_1.appendArray)(decls, (0, declarationUtils_1.getDeclarationsWithUsesLocalNameRemoved)(declsForThisImport));
                 }
             }
         }
@@ -15407,16 +15506,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // which includes every assignment of that symbol.
                         const typedDecls = symbol.getTypedDeclarations();
                         if (typedDecls.length > 0) {
-                            (0, collectionUtils_1.appendArray)(declarations, typedDecls);
+                            (0, collectionUtils_1.appendArray)(decls, typedDecls);
                         }
                         else {
-                            const synthesizedType = symbol.getSynthesizedType();
-                            if (synthesizedType) {
-                                synthesizedTypes.push({ type: synthesizedType, node });
-                            }
-                            else {
-                                (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
-                            }
+                            (0, collectionUtils_1.appendArray)(decls, symbol.getDeclarations());
+                        }
+                        const synthTypeInfo = symbol.getSynthesizedType();
+                        if (synthTypeInfo) {
+                            synthesizedTypes.push(synthTypeInfo);
                         }
                     }
                 });
@@ -15434,7 +15531,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Synthesize an alias declaration for this name part. The only
                     // time this case is used is for IDE services such as
                     // the find all references, hover provider and etc.
-                    declarations.push((0, declarationUtils_1.synthesizeAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
+                    decls.push((0, declarationUtils_1.synthesizeAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
                 }
             }
         }
@@ -15449,14 +15546,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isFunction)(baseType) && baseType.shared.declaration) {
                         const paramDecl = getDeclarationFromKeywordParam(baseType, paramName);
                         if (paramDecl) {
-                            declarations.push(paramDecl);
+                            decls.push(paramDecl);
                         }
                     }
                     else if ((0, types_1.isOverloaded)(baseType)) {
                         types_1.OverloadedType.getOverloads(baseType).forEach((f) => {
                             const paramDecl = getDeclarationFromKeywordParam(f, paramName);
                             if (paramDecl) {
-                                declarations.push(paramDecl);
+                                decls.push(paramDecl);
                             }
                         });
                     }
@@ -15465,14 +15562,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (initMethodType && (0, types_1.isFunction)(initMethodType)) {
                             const paramDecl = getDeclarationFromKeywordParam(initMethodType, paramName);
                             if (paramDecl) {
-                                declarations.push(paramDecl);
+                                decls.push(paramDecl);
                             }
                             else if (types_1.ClassType.isDataClass(baseType) ||
                                 types_1.ClassType.isTypedDictClass(baseType) ||
                                 types_1.ClassType.hasNamedTupleEntry(baseType, paramName)) {
                                 const lookupResults = (0, typeUtils_1.lookUpClassMember)(baseType, paramName);
                                 if (lookupResults) {
-                                    (0, collectionUtils_1.appendArray)(declarations, lookupResults.symbol.getDeclarations());
+                                    (0, collectionUtils_1.appendArray)(decls, lookupResults.symbol.getDeclarations());
+                                    const synthTypeInfo = lookupResults.symbol.getSynthesizedType();
+                                    if (synthTypeInfo) {
+                                        synthesizedTypes.push(synthTypeInfo);
+                                    }
                                 }
                             }
                         }
@@ -15497,10 +15598,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const allowForwardReferences = isWithinTypeAnnotation || isWithinTypeAliasStatement || fileInfo.isStubFile;
             const symbolWithScope = lookUpSymbolRecursive(node, node.d.value, !allowForwardReferences, isWithinTypeAnnotation);
             if (symbolWithScope) {
-                (0, collectionUtils_1.appendArray)(declarations, symbolWithScope.symbol.getDeclarations());
+                (0, collectionUtils_1.appendArray)(decls, symbolWithScope.symbol.getDeclarations());
+                const synthTypeInfo = symbolWithScope.symbol.getSynthesizedType();
+                if (synthTypeInfo) {
+                    synthesizedTypes.push(synthTypeInfo);
+                }
             }
         }
-        return { decls: declarations, synthesizedTypes };
+        return { decls, synthesizedTypes };
     }
     function getTypeForDeclaration(declaration) {
         var _a, _b, _c;
@@ -15607,12 +15712,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             ((_c = declaration.node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 35 /* ParseNodeType.MemberAccess */
                             ? declaration.node.parent
                             : declaration.node;
+                        const allowClassVar = ParseTreeUtils.isClassVarAllowedForAssignmentTarget(declNode);
+                        const allowFinal = ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode);
+                        const allowRequired = ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode) ||
+                            !!declaration.isInInlinedTypedDict;
                         declaredType = getTypeOfAnnotation(typeAnnotationNode, {
                             varTypeAnnotation: true,
-                            allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(declNode),
-                            allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode),
-                            allowRequired: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
-                            allowReadOnly: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
+                            allowClassVar,
+                            allowFinal,
+                            allowRequired,
+                            allowReadOnly: allowRequired,
                             enforceClassTypeVarScope: declaration.isDefinedByMemberAccess,
                         });
                     }
@@ -16270,7 +16379,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // provided, but type inference is still required. In such cases, the attributes
     // are returned as flags.
     function getDeclaredTypeOfSymbol(symbol, usageNode) {
-        const synthesizedType = symbol.getSynthesizedType();
+        var _a;
+        const synthesizedType = (_a = symbol.getSynthesizedType()) === null || _a === void 0 ? void 0 : _a.type;
         if (synthesizedType) {
             return { type: synthesizedType };
         }
@@ -16884,41 +16994,49 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Now handle generic base classes.
             destType.shared.baseClasses.forEach((baseClass) => {
-                if ((0, types_1.isInstantiableClass)(baseClass) &&
-                    !types_1.ClassType.isBuiltIn(baseClass, 'object') &&
-                    !types_1.ClassType.isBuiltIn(baseClass, 'Protocol') &&
-                    !types_1.ClassType.isBuiltIn(baseClass, 'Generic') &&
-                    baseClass.shared.typeParams.length > 0) {
-                    const specializedDestBaseClass = (0, typeUtils_1.specializeForBaseClass)(destType, baseClass);
-                    const specializedSrcBaseClass = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
-                    if (!ignoreBaseClassVariance) {
-                        specializedDestBaseClass.shared.typeParams.forEach((param, index) => {
-                            if (!(0, types_1.isParamSpec)(param) &&
-                                !(0, types_1.isTypeVarTuple)(param) &&
-                                !param.shared.isSynthesized &&
-                                specializedSrcBaseClass.priv.typeArgs &&
-                                index < specializedSrcBaseClass.priv.typeArgs.length &&
-                                specializedDestBaseClass.priv.typeArgs &&
-                                index < specializedDestBaseClass.priv.typeArgs.length) {
-                                const paramVariance = param.shared.declaredVariance;
-                                if ((0, types_1.isTypeVar)(specializedSrcBaseClass.priv.typeArgs[index])) {
-                                    if (paramVariance === 2 /* Variance.Invariant */ ||
-                                        paramVariance === 4 /* Variance.Contravariant */) {
-                                        isAssignable = false;
-                                    }
-                                }
-                                else if ((0, types_1.isTypeVar)(specializedDestBaseClass.priv.typeArgs[index])) {
-                                    if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 3 /* Variance.Covariant */) {
-                                        isAssignable = false;
-                                    }
-                                }
+                if (!isAssignable ||
+                    !(0, types_1.isInstantiableClass)(baseClass) ||
+                    types_1.ClassType.isBuiltIn(baseClass, ['object', 'Protocol', 'Generic']) ||
+                    baseClass.shared.typeParams.length === 0) {
+                    return;
+                }
+                const specializedDestBaseClass = (0, typeUtils_1.specializeForBaseClass)(destType, baseClass);
+                const specializedSrcBaseClass = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
+                if (!ignoreBaseClassVariance) {
+                    specializedDestBaseClass.shared.typeParams.forEach((param, index) => {
+                        if ((0, types_1.isParamSpec)(param) || (0, types_1.isTypeVarTuple)(param) || param.shared.isSynthesized) {
+                            return;
+                        }
+                        if (!specializedSrcBaseClass.priv.typeArgs ||
+                            index >= specializedSrcBaseClass.priv.typeArgs.length ||
+                            !specializedDestBaseClass.priv.typeArgs ||
+                            index >= specializedDestBaseClass.priv.typeArgs.length) {
+                            return;
+                        }
+                        const paramVariance = param.shared.declaredVariance;
+                        if ((0, types_1.isTypeVar)(specializedSrcBaseClass.priv.typeArgs[index])) {
+                            if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 4 /* Variance.Contravariant */) {
+                                isAssignable = false;
+                                return;
                             }
-                        });
-                    }
-                    if (isAssignable &&
-                        !assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, assumedVariance, ignoreBaseClassVariance, recursionCount)) {
-                        isAssignable = false;
-                    }
+                        }
+                        if ((0, types_1.isTypeVar)(specializedDestBaseClass.priv.typeArgs[index])) {
+                            if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 3 /* Variance.Covariant */) {
+                                isAssignable = false;
+                                return;
+                            }
+                        }
+                    });
+                }
+                if (!isAssignable) {
+                    return;
+                }
+                // Handle tuples specially since their type arguments are variadic.
+                if (types_1.ClassType.isTupleClass(specializedDestBaseClass)) {
+                    return;
+                }
+                if (!assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, assumedVariance, ignoreBaseClassVariance, recursionCount)) {
+                    isAssignable = false;
                 }
             });
             return isAssignable;
@@ -17430,7 +17548,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // the metaclass of the instantiable dest type.
                 const destMetaclass = destType.shared.effectiveMetaclass;
                 if (destMetaclass && (0, types_1.isInstantiableClass)(destMetaclass)) {
-                    if (assignClass(types_1.ClassType.cloneAsInstance(destMetaclass), expandedSrcType, diag, constraints, flags, recursionCount, 
+                    if (assignClass(destMetaclass, types_1.ClassType.cloneAsInstantiable(expandedSrcType), diag, constraints, flags, recursionCount, 
                     /* reportErrorsUsingObjType */ false)) {
                         return true;
                     }
@@ -19114,6 +19232,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         var _a, _b;
         const baseParamDetails = (0, parameterUtils_1.getParamListDetails)(baseMethod);
         const overrideParamDetails = (0, parameterUtils_1.getParamListDetails)(overrideMethod);
+        const constraints = new constraintTracker_1.ConstraintTracker();
         let canOverride = true;
         if (!types_1.FunctionType.isGradualCallableForm(baseMethod) && !types_1.FunctionType.isGradualCallableForm(overrideMethod)) {
             // Verify that we're not overriding a static, class or instance method with
@@ -19146,8 +19265,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     const overrideArgsType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
                     for (let i = overrideParamDetails.positionParamCount; i < baseParamDetails.positionParamCount; i++) {
-                        if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                        if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 2 /* AssignTypeFlags.Contravariant */)) {
                             localize_1.LocAddendum.overrideParamType().format({
                                 index: i + 1,
                                 baseType: printType(baseParamDetails.params[i].type),
@@ -19236,8 +19354,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.shared.isSynthesized;
                     if (!exemptSelfClsParam || (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar)) {
                         if (baseParam.category !== overrideParam.category ||
-                            !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                            !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 2 /* AssignTypeFlags.Contravariant */)) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamType().format({
                                 index: i + 1,
                                 baseType: printType(baseParamType),
@@ -19279,8 +19396,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     const overrideParamType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
                     const baseParamType = baseParamDetails.params[baseParamDetails.argsIndex].type;
-                    if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                    /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                    if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 2 /* AssignTypeFlags.Contravariant */)) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordType().format({
                             name: (_b = overrideParamDetails.params[overrideParamDetails.argsIndex].param.name) !== null && _b !== void 0 ? _b : '?',
                             baseType: printType(baseParamType),
@@ -19307,8 +19423,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (!targetParamType) {
                         targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
                     }
-                    if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                    /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                    if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 2 /* AssignTypeFlags.Contravariant */)) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordType().format({
                             name: (_b = paramInfo.param.name) !== null && _b !== void 0 ? _b : '?',
                             baseType: printType(paramInfo.type),
@@ -19366,8 +19481,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Now check the return type.
         const baseReturnType = getEffectiveReturnType(baseMethod);
         const overrideReturnType = getEffectiveReturnType(overrideMethod);
-        if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+        if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 0 /* AssignTypeFlags.Default */)) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideReturnType().format({
                 baseType: printType(baseReturnType),
                 overrideType: printType(overrideReturnType),