@zzzen/pyright-internal 1.2.0-dev.20240324 → 1.2.0-dev.20240407

package/dist/analyzer/typeEvaluator.js

@@ -1421,13 +1421,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 subDiag = metaclassDiag;
             }
         }
-        if (memberInfo && !memberInfo.isDescriptorError) {
+        if (memberInfo) {
+            if (memberInfo.isDescriptorError && diag && subDiag) {
+                diag.addAddendum(subDiag);
+            }
             return {
                 type: memberInfo.type,
                 classType: memberInfo.classType,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
                 memberAccessDeprecationInfo: memberInfo.memberAccessDeprecationInfo,
+                typeErrors: memberInfo.isDescriptorError,
             };
         }
         // If this is a type[Any] or type[Unknown], allow any other members.
@@ -1545,7 +1549,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         let constructorType;
                         // Try to get the `__init__` method first because it typically has more
                         // type information than `__new__`.
-                        const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, callNode, types_1.ClassType.cloneAsInstance(subtype), 0 /* MemberAccessFlags.Default */);
+                        const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, callNode, types_1.ClassType.cloneAsInstance(subtype), 
+                        /* diag */ undefined, 0 /* MemberAccessFlags.Default */);
                         if (initMethodResult && !initMethodResult.typeErrors) {
                             if ((0, types_1.isFunction)(initMethodResult.type) || (0, types_1.isOverloadedFunction)(initMethodResult.type)) {
                                 constructorType = initMethodResult.type;
@@ -1561,7 +1566,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // the `object` class or accepts only default parameters(* args, ** kwargs),
                         // see if we can find a better signature from the `__new__` method.
                         if (!constructorType || isObjectInit || isDefaultParams) {
-                            const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluatorInterface, callNode, subtype, 0 /* MemberAccessFlags.Default */);
+                            const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluatorInterface, callNode, subtype);
                             if (newMethodResult && !newMethodResult.typeErrors) {
                                 if ((0, types_1.isFunction)(newMethodResult.type) &&
                                     newMethodResult.type.details.fullName !== 'builtins.object.__new__') {
@@ -2277,7 +2282,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // Assignments to instance or class variables through "self" or "cls" is not
                     // allowed for protocol classes unless it is also declared within the class.
                     if (types_1.ClassType.isProtocolClass(classTypeResults.classType)) {
-                        const memberSymbol = classTypeResults.classType.details.fields.get(target.memberName.value);
+                        const memberSymbol = types_1.ClassType.getSymbolTable(classTypeResults.classType).get(target.memberName.value);
                         if (memberSymbol) {
                             const classLevelDecls = memberSymbol.getDeclarations().filter((decl) => {
                                 return !ParseTreeUtils.getEnclosingFunction(decl.node);
@@ -2318,7 +2323,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const classTypeInfo = getTypeOfClass(classDef);
         if (classTypeInfo && (0, types_1.isInstantiableClass)(classTypeInfo.classType)) {
             let memberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, memberName, isInstanceMember ? 0 /* MemberAccessFlags.Default */ : 16 /* MemberAccessFlags.SkipInstanceMembers */);
-            const memberFields = classTypeInfo.classType.details.fields;
+            const memberFields = types_1.ClassType.getSymbolTable(classTypeInfo.classType);
             if (memberInfo) {
                 // Are we accessing an existing member on this class, or is
                 // it a member on a parent class?
@@ -2326,12 +2331,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const isThisClass = memberClass && types_1.ClassType.isSameGenericClass(classTypeInfo.classType, memberClass);
                 // Check for an attempt to write to an instance variable that is
                 // not defined by __slots__.
-                if (isThisClass && isInstanceMember) {
-                    if ((memberClass === null || memberClass === void 0 ? void 0 : memberClass.details.inheritedSlotsNames) && memberClass.details.localSlotsNames) {
+                if (isThisClass && isInstanceMember && memberClass) {
+                    const inheritedSlotsNames = types_1.ClassType.getInheritedSlotsNames(memberClass);
+                    if (inheritedSlotsNames && memberClass.details.localSlotsNames) {
                         // Skip this check if the local slots is specified but empty because this pattern
                         // is used in a legitimate manner for mix-in classes.
                         if (memberClass.details.localSlotsNames.length > 0 &&
-                            !memberClass.details.inheritedSlotsNames.some((name) => name === memberName)) {
+                            !inheritedSlotsNames.some((name) => name === memberName)) {
                             // Determine whether the assignment corresponds to a descriptor
                             // that was assigned as a class variable. If so, then slots will not
                             // apply in this case.
@@ -3611,18 +3617,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeResult = getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, 
                     /* memberAccessFlags */ undefined, baseTypeResult.bindToSelfType);
                 }
-                if (typeResult) {
+                if (typeResult && !typeResult.typeErrors) {
                     type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), 
                     /* skipSelfCondition */ true);
-                }
-                if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete) {
-                    isIncomplete = true;
-                }
-                if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricAccessor) {
-                    isAsymmetricAccessor = true;
-                }
-                if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
-                    memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
+                    if (typeResult.isIncomplete) {
+                        isIncomplete = true;
+                    }
+                    if (typeResult.isAsymmetricAccessor) {
+                        isAsymmetricAccessor = true;
+                    }
+                    if (typeResult.memberAccessDeprecationInfo) {
+                        memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
+                    }
                 }
                 break;
             }
@@ -3701,7 +3707,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if ((0, typeUtils_1.isNoneInstance)(subtype) && noneType && (0, types_1.isClassInstance)(noneType)) {
                         const typeResult = getTypeOfBoundMember(node.memberName, noneType, memberName, usage, diag);
-                        if (typeResult) {
+                        if (typeResult && !typeResult.typeErrors) {
                             type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
                             if (typeResult.isIncomplete) {
                                 isIncomplete = true;
@@ -3766,6 +3772,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (usage.setExpectedTypeDiag) {
                     diag = usage.setExpectedTypeDiag;
                 }
+                // If the class is a TypedDict, and there's a key with the same name,
+                // suggest that they user want to use ["key"] name instead.
+                if ((0, types_1.isClass)(baseType) && baseType.details.typedDictEntries) {
+                    const tdKey = baseType.details.typedDictEntries.knownItems.get(memberName);
+                    if (tdKey) {
+                        const subDiag = new diagnostic_1.DiagnosticAddendum();
+                        subDiag.addMessage(localize_1.LocAddendum.typedDictKeyAccess().format({ name: memberName }));
+                        diag.addAddendum(subDiag);
+                    }
+                }
                 const rule = isFunctionRule
                     ? diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess
                     : diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue;
@@ -3837,7 +3853,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // this is normally considered a type violation. But it is allowed
                     // if the class variable is a descriptor object. In this case, we will
                     // clear the flag that causes an error to be generated.
-                    if (usage.method === 'set' && memberInfo.symbol.isClassVar() && isAccessedThroughObject) {
+                    if (usage.method === 'set' &&
+                        (0, symbolUtils_1.isEffectivelyClassVar)(memberInfo.symbol, types_1.ClassType.isDataClass(containingClassType)) &&
+                        isAccessedThroughObject) {
                         const selfClass = (selfType !== null && selfType !== void 0 ? selfType : memberName === '__new__') ? undefined : classType;
                         const typeResult = getTypeOfMemberInternal(errorNode, memberInfo, selfClass, flags);
                         if (typeResult) {
@@ -3937,7 +3955,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             // Check for an attempt to overwrite or delete a ClassVar member from an instance.
             if (!isDescriptorApplied &&
-                (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.isClassVar()) &&
+                memberInfo &&
+                (0, symbolUtils_1.isEffectivelyClassVar)(memberInfo.symbol, types_1.ClassType.isDataClass(classType)) &&
                 (flags & 128 /* MemberAccessFlags.DisallowClassVarWrites */) !== 0) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.memberSetClassVar().format({ name: memberName }));
                 isDescriptorError = true;
@@ -4015,7 +4034,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const methodTypeResult = getTypeOfBoundMember(errorNode, concreteMemberType, accessMethodName, 
         /* usage */ undefined, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */);
-        if (!methodTypeResult) {
+        if (!methodTypeResult || methodTypeResult.typeErrors) {
             // Provide special error messages for properties.
             if (types_1.ClassType.isPropertyClass(concreteMemberType)) {
                 if (usage.method !== 'get') {
@@ -6615,7 +6634,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // are more complicated and depend on whether the method is defined in a stub file.
     function getAbstractSymbolInfo(classType, symbolName) {
         const isProtocolClass = types_1.ClassType.isProtocolClass(classType);
-        const symbol = classType.details.fields.get(symbolName);
+        const symbol = types_1.ClassType.getSymbolTable(classType).get(symbolName);
         if (!symbol) {
             return undefined;
         }
@@ -6792,7 +6811,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const result = {
                     returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ true),
                 };
-                const initTypeResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), 0 /* MemberAccessFlags.Default */);
+                const initTypeResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), 
+                /* diag */ undefined, 0 /* MemberAccessFlags.Default */);
                 if (initTypeResult && (0, types_1.isOverloadedFunction)(initTypeResult.type)) {
                     validateOverloadedFunctionArguments(errorNode, argList, { type: initTypeResult.type }, 
                     /* typeVarContext */ undefined, skipUnknownArgCheck, 
@@ -6895,15 +6915,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
         var _a;
+        const callDiag = new diagnostic_1.DiagnosticAddendum();
         const callMethodResult = getTypeOfBoundMember(errorNode, expandedCallType, '__call__', 
-        /* usage */ undefined, 
-        /* diag */ undefined, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, 
+        /* usage */ undefined, callDiag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, 
         /* selfType */ undefined, recursionCount);
         const callMethodType = callMethodResult === null || callMethodResult === void 0 ? void 0 : callMethodResult.type;
-        if (!callMethodType) {
+        if (!callMethodType || callMethodResult.typeErrors) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
                 type: printType(expandedCallType),
-            }), errorNode);
+            }) + callDiag.getString(), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
         }
         const callResult = validateCallArguments(errorNode, argList, { type: callMethodType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
@@ -9103,7 +9123,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 hasDeclaredType: true,
             });
             initType.details.declaredReturnType = getNoneType();
-            classType.details.fields.set('__init__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, initType));
+            types_1.ClassType.getSymbolTable(classType).set('__init__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, initType));
             // Synthesize a trivial __new__ method.
             const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* FunctionTypeFlags.ConstructorMethod */);
             types_1.FunctionType.addParameter(newType, {
@@ -9114,7 +9134,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             types_1.FunctionType.addDefaultParameters(newType);
             newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
-            classType.details.fields.set('__new__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, newType));
+            newType.details.constructorTypeVarScopeId = classType.details.typeVarScopeId;
+            types_1.ClassType.getSymbolTable(classType).set('__new__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, newType));
         }
         return classType;
     }
@@ -9420,7 +9441,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isIncomplete = false;
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
-            var _a;
+            var _a, _b, _c, _d;
             let addUnknown = true;
             if (entryNode.nodeType === 17 /* ParseNodeType.DictionaryKeyEntry */) {
                 const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, 
@@ -9467,6 +9488,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncomplete = true;
                 }
                 if (forceStrictInference || index < maxEntriesToUseForInference) {
+                    // If an existing key has the same literal type, delete the previous
+                    // key since we're overwriting it here.
+                    if ((0, types_1.isClass)(keyType) && (0, typeUtils_1.isLiteralType)(keyType)) {
+                        const existingIndex = keyTypes.findIndex((kt) => (0, types_1.isTypeSame)(keyType, kt.type));
+                        if (existingIndex >= 0) {
+                            keyTypes.splice(existingIndex, 1);
+                            valueTypes.splice(existingIndex, 1);
+                        }
+                    }
                     keyTypes.push({ node: entryNode.keyExpression, type: keyType });
                     valueTypes.push({ node: entryNode.valueExpression, type: valueType });
                 }
@@ -9504,10 +9534,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         /* allowNarrowed */ true);
                         tdEntries.knownItems.forEach((entry, name) => {
                             if (entry.isRequired || entry.isProvided) {
-                                keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneWithLiteral(strObject, name) });
+                                keyTypes.push({
+                                    node: entryNode,
+                                    type: types_1.ClassType.cloneWithLiteral(strObject, name),
+                                });
                                 valueTypes.push({ node: entryNode, type: entry.valueType });
                             }
                         });
+                        if (!expectedTypedDictEntries) {
+                            keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneAsInstance(strObject) });
+                            valueTypes.push({
+                                node: entryNode,
+                                type: (_c = (_b = (_a = tdEntries.extraItems) === null || _a === void 0 ? void 0 : _a.valueType) !== null && _b !== void 0 ? _b : objectType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create(),
+                            });
+                        }
                         addUnknown = false;
                     }
                 }
@@ -9541,7 +9581,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // The result should be a tuple.
                 if ((0, types_1.isClassInstance)(dictEntryType) && (0, typeUtils_1.isTupleClass)(dictEntryType)) {
-                    const typeArgs = (_a = dictEntryType.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.map((t) => t.type);
+                    const typeArgs = (_d = dictEntryType.tupleTypeArguments) === null || _d === void 0 ? void 0 : _d.map((t) => t.type);
                     if (typeArgs && typeArgs.length === 2) {
                         if (forceStrictInference || index < maxEntriesToUseForInference) {
                             keyTypes.push({ node: entryNode, type: typeArgs[0] });
@@ -9675,7 +9715,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const specializedListOrSet = (0, typeUtils_1.applySolvedTypeVars)(expectedClassType, typeVarContext);
-        if (!specializedListOrSet.typeArguments || specializedListOrSet.typeArguments.length !== 1) {
+        if (!specializedListOrSet.typeArguments) {
             return undefined;
         }
         return specializedListOrSet.typeArguments[0];
@@ -10025,7 +10065,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (ParseTreeUtils.containsAwaitNode(node.expression)) {
             isAsync = true;
         }
-        const expectedEntryType = getExpectedEntryTypeForIterable(node, getTypingType(node, 'Iterable'), inferenceContext);
+        const builtInIteratorType = getTypingType(node, isAsync ? 'AsyncGenerator' : 'Generator');
+        const expectedEntryType = getExpectedEntryTypeForIterable(node, builtInIteratorType, inferenceContext);
         const elementTypeResult = getElementTypeFromListComprehension(node, expectedEntryType);
         if (elementTypeResult.isIncomplete) {
             isIncomplete = true;
@@ -10033,8 +10074,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (elementTypeResult.typeErrors) {
             typeErrors = true;
         }
-        const elementType = elementTypeResult.type;
-        const builtInIteratorType = getTypingType(node, isAsync ? 'AsyncGenerator' : 'Generator');
+        let elementType = elementTypeResult.type;
+        if (!expectedEntryType || !(0, typeUtils_1.containsLiteralType)(expectedEntryType)) {
+            elementType = stripLiteralValue(elementType);
+        }
         if (builtInIteratorType && (0, types_1.isInstantiableClass)(builtInIteratorType)) {
             type = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(builtInIteratorType, isAsync ? [elementType, getNoneType()] : [elementType, getNoneType(), getNoneType()], 
             /* isTypeArgumentExplicit */ true));
@@ -11028,6 +11071,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (aliasMapEntry.isSpecialForm) {
             specialClassType.details.flags |= -2147483648 /* ClassTypeFlags.SpecialFormClass */;
         }
+        // Synthesize a single type parameter with the specified variance if
+        // specified in the alias map entry.
+        if (aliasMapEntry.typeParamVariance !== undefined) {
+            let typeParam = types_1.TypeVarType.createInstance('T');
+            typeParam = types_1.TypeVarType.cloneForScopeId(typeParam, ParseTreeUtils.getScopeIdForNode(node), assignedName, 0 /* TypeVarScopeType.Class */);
+            typeParam.details.declaredVariance = aliasMapEntry.typeParamVariance;
+            specialClassType.details.typeParameters.push(typeParam);
+        }
         const specialBuiltInClassDeclaration = ((_a = AnalyzerNodeInfo.getDeclaration(node)) !== null && _a !== void 0 ? _a : (node.parent ? AnalyzerNodeInfo.getDeclaration(node.parent) : undefined));
         specialClassType.details.declaration = specialBuiltInClassDeclaration;
         if (fileInfo.isTypingExtensionsStubFile) {
@@ -11098,7 +11149,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ['Annotated', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['TypeAlias', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['Concatenate', { alias: '', module: 'builtins', isSpecialForm: true }],
-            ['TypeGuard', { alias: '', module: 'builtins', isSpecialForm: true }],
+            [
+                'TypeGuard',
+                { alias: '', module: 'builtins', isSpecialForm: true, typeParamVariance: 3 /* Variance.Covariant */ },
+            ],
             ['Unpack', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['Required', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['NotRequired', { alias: '', module: 'builtins', isSpecialForm: true }],
@@ -11107,7 +11161,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ['Never', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['LiteralString', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['ReadOnly', { alias: '', module: 'builtins', isSpecialForm: true }],
-            ['TypeIs', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['TypeIs', { alias: '', module: 'builtins', isSpecialForm: true, typeParamVariance: 2 /* Variance.Invariant */ }],
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
@@ -11485,6 +11539,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // all of the type parameters in the specified order.
             let genericTypeParameters;
             let protocolTypeParameters;
+            let isNamedTupleSubclass = false;
             const initSubclassArgs = [];
             let metaclassNode;
             let exprFlags = 128 /* EvaluatorFlags.ExpectingInstantiableType */ |
@@ -11564,6 +11619,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // newer), it's considered a (read-only) dataclass.
                             if (fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_6)) {
                                 if (types_1.ClassType.isBuiltIn(argType, 'NamedTuple')) {
+                                    isNamedTupleSubclass = true;
                                     classType.details.flags |=
                                         4 /* ClassTypeFlags.DataClass */ |
                                             32 /* ClassTypeFlags.SkipSynthesizedDataClassEq */ |
@@ -11922,46 +11978,62 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // See if there's already a non-synthesized __init__ method.
                 // We shouldn't override it.
                 if (!skipSynthesizedInit) {
-                    const initSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 2 /* MemberAccessFlags.SkipBaseClasses */);
-                    if (initSymbol) {
+                    const initSymbol = classType.details.fields.get('__init__');
+                    if (initSymbol && initSymbol.isClassMember()) {
                         hasExistingInitMethod = true;
                     }
                 }
                 let skipSynthesizeHash = false;
-                const hashSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__hash__', 2 /* MemberAccessFlags.SkipBaseClasses */);
+                const hashSymbol = classType.details.fields.get('__hash__');
                 // If there is a hash symbol defined in the class (i.e. one that we didn't
                 // synthesize above), then we shouldn't synthesize a new one for the dataclass.
-                if (hashSymbol && !hashSymbol.symbol.getSynthesizedType()) {
+                if (hashSymbol && hashSymbol.isClassMember() && !hashSymbol.getSynthesizedType()) {
                     skipSynthesizeHash = true;
                 }
-                (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
+                const synthesizeMethods = () => (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
+                // If this is a NamedTuple subclass, immediately synthesize dataclass methods
+                // because we also need to update the MRO classes in this case. For regular
+                // dataclasses, we'll defer the  method synthesis to avoid circular dependencies.
+                if (isNamedTupleSubclass) {
+                    synthesizeMethods();
+                }
+                else {
+                    classType.details.synthesizeMethodsDeferred = () => {
+                        delete classType.details.synthesizeMethodsDeferred;
+                        synthesizeMethods();
+                    };
+                }
             }
             // Build a complete list of all slots names defined by the class hierarchy.
             // This needs to be done after dataclass processing.
-            if (classType.details.localSlotsNames) {
-                let isLimitedToSlots = true;
-                const extendedSlotsNames = Array.from(classType.details.localSlotsNames);
-                classType.details.baseClasses.forEach((baseClass) => {
-                    if ((0, types_1.isInstantiableClass)(baseClass)) {
-                        if (!types_1.ClassType.isBuiltIn(baseClass, 'object') &&
-                            !types_1.ClassType.isBuiltIn(baseClass, 'type') &&
-                            !types_1.ClassType.isBuiltIn(baseClass, 'Generic')) {
-                            if (baseClass.details.inheritedSlotsNames === undefined) {
-                                isLimitedToSlots = false;
-                            }
-                            else {
-                                (0, collectionUtils_1.appendArray)(extendedSlotsNames, baseClass.details.inheritedSlotsNames);
+            classType.details.calculateInheritedSlotsNamesDeferred = () => {
+                delete classType.details.calculateInheritedSlotsNamesDeferred;
+                if (classType.details.localSlotsNames) {
+                    let isLimitedToSlots = true;
+                    const extendedSlotsNames = Array.from(classType.details.localSlotsNames);
+                    classType.details.baseClasses.forEach((baseClass) => {
+                        if ((0, types_1.isInstantiableClass)(baseClass)) {
+                            if (!types_1.ClassType.isBuiltIn(baseClass, 'object') &&
+                                !types_1.ClassType.isBuiltIn(baseClass, 'type') &&
+                                !types_1.ClassType.isBuiltIn(baseClass, 'Generic')) {
+                                const inheritedSlotsNames = types_1.ClassType.getInheritedSlotsNames(baseClass);
+                                if (inheritedSlotsNames) {
+                                    (0, collectionUtils_1.appendArray)(extendedSlotsNames, inheritedSlotsNames);
+                                }
+                                else {
+                                    isLimitedToSlots = false;
+                                }
                             }
                         }
+                        else {
+                            isLimitedToSlots = false;
+                        }
+                    });
+                    if (isLimitedToSlots) {
+                        classType.details.inheritedSlotsNamesCached = extendedSlotsNames;
                     }
-                    else {
-                        isLimitedToSlots = false;
-                    }
-                });
-                if (isLimitedToSlots) {
-                    classType.details.inheritedSlotsNames = extendedSlotsNames;
                 }
-            }
+            };
             // Update the undecorated class type.
             writeTypeCache(node.name, { type: classType }, 0 /* EvaluatorFlags.None */);
             // Update the decorated class type.
@@ -12526,6 +12598,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 else {
                     annotatedType = getTypeOfParameterAnnotation(paramTypeNode, param.category);
                 }
+                if (annotatedType) {
+                    (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(annotatedType), functionType.details.typeVarScopeId);
+                }
                 if ((0, types_1.isVariadicTypeVar)(annotatedType) && !annotatedType.isVariadicUnpacked) {
                     addError(localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
                         name1: annotatedType.details.name,
@@ -12631,7 +12706,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             };
             types_1.FunctionType.addParameter(functionType, functionParam);
             if (functionParam.hasDeclaredType) {
-                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionParam.type));
+                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionParam.type), functionType.details.typeVarScopeId);
             }
             if (param.name) {
                 const variadicParamType = transformVariadicParamType(node, param.category, functionParam.type);
@@ -12812,7 +12887,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // of the child class.
                             if ((0, typeUtils_1.requiresSpecialization)(inferredParamType) && (0, types_1.isClass)(baseClassMemberInfo.classType)) {
                                 const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClassMemberInfo.classType);
-                                inferredParamType = (0, typeUtils_1.applySolvedTypeVars)(inferredParamType, typeVarContext);
+                                // Add the scope of the method to handle any function-scoped TypeVars.
+                                typeVarContext.addSolveForScope(ParseTreeUtils.getScopeIdForNode(baseClassMethodNode));
+                                // Replace any unsolved TypeVars with Unknown (including all function-scoped TypeVars).
+                                inferredParamType = (0, typeUtils_1.applySolvedTypeVars)(inferredParamType, typeVarContext, {
+                                    unknownIfNotFound: true,
+                                });
                             }
                             const fileInfo = AnalyzerNodeInfo.getFileInfo(functionNode);
                             if (fileInfo.isInPyTypedPackage && !fileInfo.isStubFile) {
@@ -15472,7 +15552,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If the symbol is explicitly marked as a ClassVar, consider only the
             // declarations that assign to it from within the class body, not through
             // a member access expression.
-            if (symbol.isClassVar() && decl.type === 1 /* DeclarationType.Variable */ && decl.isDefinedByMemberAccess) {
+            if ((0, symbolUtils_1.isEffectivelyClassVar)(symbol, /* isDataclass */ false) &&
+                decl.type === 1 /* DeclarationType.Variable */ &&
+                decl.isDefinedByMemberAccess) {
                 return;
             }
             if (usageNode !== undefined) {
@@ -16123,7 +16205,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Stash the current class type so any references to it are treated
             // as though all TypeParameters are invariant.
             assignClassToSelfStack.push({ class: destType, assumedVariance });
-            destType.details.fields.forEach((symbol, name) => {
+            types_1.ClassType.getSymbolTable(destType).forEach((symbol, name) => {
                 if (!isAssignable || symbol.isIgnoredForProtocolMatch()) {
                     return;
                 }
@@ -16960,7 +17042,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else if (types_1.ClassType.isBuiltIn(destType, ['TypeGuard', 'TypeIs'])) {
-                // All the source to be a "bool".
+                // Allow the source to be a "bool".
                 if ((originalFlags & 128 /* AssignTypeFlags.AllowBoolTypeGuard */) !== 0) {
                     if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'bool')) {
                         return true;
@@ -17572,11 +17654,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // a normal function wouldn't be compatible with.
         for (const mroClass of objType.details.mro) {
             if ((0, types_1.isClass)(mroClass) && types_1.ClassType.isProtocolClass(mroClass)) {
-                for (const field of mroClass.details.fields) {
+                for (const field of types_1.ClassType.getSymbolTable(mroClass)) {
                     if (field[0] !== '__call__' && !field[1].isIgnoredForProtocolMatch()) {
                         let fieldIsPartOfFunction = false;
                         if (functionObj && (0, types_1.isClass)(functionObj)) {
-                            if (functionObj.details.fields.has(field[0])) {
+                            if (types_1.ClassType.getSymbolTable(functionObj).has(field[0])) {
                                 fieldIsPartOfFunction = true;
                             }
                         }
@@ -18791,7 +18873,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // See if this class is introducing a new abstract symbol that has not been
                 // introduced previously or if it is overriding an abstract symbol with
                 // a non-abstract one.
-                mroClass.details.fields.forEach((symbol, symbolName) => {
+                types_1.ClassType.getSymbolTable(mroClass).forEach((symbol, symbolName) => {
                     const abstractSymbolInfo = getAbstractSymbolInfo(mroClass, symbolName);
                     if (abstractSymbolInfo) {
                         symbolTable.set(symbolName, abstractSymbolInfo);
@@ -19040,11 +19122,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.strings[0].nodeType === 49 /* ParseNodeType.String */) {
             valueOffset += node.strings[0].token.prefixLength + node.strings[0].token.quoteMarkLength;
         }
+        // Construct a temporary dummy string with the text value at the appropriate
+        // offset so as to mimic the original file. This will keep all of the token
+        // and diagnostic offsets correct.
+        const dummyFileContents = ' '.repeat(valueOffset) + textValue;
         const parseOptions = new parser_1.ParseOptions();
         parseOptions.isStubFile = fileInfo.isStubFile;
         parseOptions.pythonVersion = fileInfo.executionEnvironment.pythonVersion;
         parseOptions.reportErrorsForParsedStringContents = true;
-        const parseResults = parser.parseTextExpression(fileInfo.fileContents, valueOffset, textValue.length, parseOptions, 
+        const parseResults = parser.parseTextExpression(dummyFileContents, valueOffset, textValue.length, parseOptions, 
         /* parseTextMode */ undefined, 
         /* initialParenDepth */ undefined, fileInfo.typingSymbolAliases);
         if (parseResults.parseTree && parseResults.parseTree.nodeType !== 62 /* ParseNodeType.FunctionAnnotation */) {