@zzzen/pyright-internal 1.2.0-dev.20240331 → 1.2.0-dev.20240414

package/dist/analyzer/typeEvaluator.js

@@ -890,12 +890,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeResult = getTypeOfExpression(node.typeAnnotation, updatedFlags);
             }
             else if (!node.typeAnnotation && node.strings.length === 1) {
-                // We didn't know at parse time that this string node was going
-                // to be evaluated as a forward-referenced type. We need
-                // to re-invoke the parser at this stage.
-                const expr = parseStringAsTypeAnnotation(node);
-                if (expr) {
-                    typeResult = getTypeOfExpression(expr, updatedFlags);
+                const tokenFlags = node.strings[0].token.flags;
+                if (tokenFlags & 32 /* StringTokenFlags.Bytes */) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationBytesString(), node);
+                    typeResult = { type: types_1.UnknownType.create() };
+                }
+                else if (tokenFlags & 8 /* StringTokenFlags.Raw */) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationRawString(), node);
+                    typeResult = { type: types_1.UnknownType.create() };
+                }
+                else if (tokenFlags & 64 /* StringTokenFlags.Format */) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationFormatString(), node);
+                    typeResult = { type: types_1.UnknownType.create() };
+                }
+                else {
+                    // We didn't know at parse time that this string node was going
+                    // to be evaluated as a forward-referenced type. We need
+                    // to re-invoke the parser at this stage.
+                    const expr = parseStringAsTypeAnnotation(node);
+                    if (expr) {
+                        typeResult = getTypeOfExpression(expr, updatedFlags);
+                    }
                 }
             }
             if (!typeResult) {
@@ -1430,6 +1445,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 classType: memberInfo.classType,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
+                narrowedTypeForSet: memberInfo.narrowedTypeForSet,
                 memberAccessDeprecationInfo: memberInfo.memberAccessDeprecationInfo,
                 typeErrors: memberInfo.isDescriptorError,
             };
@@ -2258,6 +2274,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(nameNode, { type: destType, isIncomplete: isTypeIncomplete }, 0 /* EvaluatorFlags.None */);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
+        var _a;
         const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */);
         const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
         // Handle member accesses (e.g. self.x or cls.y).
@@ -2282,7 +2299,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);
@@ -2305,7 +2322,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             setAsymmetricDescriptorAssignment(target);
         }
         const resultToCache = {
-            type,
+            type: (_a = setTypeResult.narrowedTypeForSet) !== null && _a !== void 0 ? _a : type,
             isIncomplete: isTypeIncomplete,
             memberAccessDeprecationInfo: setTypeResult.memberAccessDeprecationInfo,
         };
@@ -2323,7 +2340,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?
@@ -2331,12 +2348,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.
@@ -2932,7 +2950,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (typeParamSymbol) {
             symbol = typeParamSymbol;
             (0, debug_1.assert)(symbol.getDeclarations().length === 1);
-            const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+            const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(symbol);
             (0, debug_1.assert)((decl === null || decl === void 0 ? void 0 : decl.type) === 3 /* DeclarationType.TypeParameter */);
             type = getTypeOfTypeParameter(decl.node);
             setSymbolAccessed(fileInfo, symbol, node);
@@ -3532,6 +3550,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let diag = new diagnostic_1.DiagnosticAddendum();
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         let type;
+        let narrowedTypeForSet;
+        let typeErrors = false;
         let isIncomplete = !!baseTypeResult.isIncomplete;
         let isAsymmetricAccessor;
         const isRequired = false;
@@ -3616,15 +3636,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeResult = getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, 
                     /* memberAccessFlags */ undefined, baseTypeResult.bindToSelfType);
                 }
-                if (typeResult && !typeResult.typeErrors) {
-                    type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), 
-                    /* skipSelfCondition */ true);
-                    if (typeResult.isIncomplete) {
-                        isIncomplete = true;
+                if (typeResult) {
+                    if (!typeResult.typeErrors) {
+                        type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), 
+                        /* skipSelfCondition */ true);
+                    }
+                    else {
+                        typeErrors = true;
                     }
                     if (typeResult.isAsymmetricAccessor) {
                         isAsymmetricAccessor = true;
                     }
+                    if (typeResult.isIncomplete) {
+                        isIncomplete = true;
+                    }
+                    if (typeResult.narrowedTypeForSet) {
+                        narrowedTypeForSet = (0, typeUtils_1.addConditionToType)(typeResult.narrowedTypeForSet, (0, typeUtils_1.getTypeCondition)(baseType), 
+                        /* skipSelfCondition */ true);
+                    }
                     if (typeResult.memberAccessDeprecationInfo) {
                         memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
                     }
@@ -3725,9 +3754,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (typeResult.isIncomplete) {
                         isIncomplete = true;
                     }
-                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
+                    if (typeResult.memberAccessDeprecationInfo) {
                         memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
                     }
+                    if (typeResult.typeErrors) {
+                        typeErrors = true;
+                    }
                     return typeResult.type;
                 });
                 break;
@@ -3771,6 +3803,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;
@@ -3784,7 +3826,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) === 0) {
             reportUseOfTypeCheckOnly(type, node.memberName);
         }
-        return { type, isIncomplete, isAsymmetricAccessor, isRequired, isNotRequired, memberAccessDeprecationInfo };
+        return {
+            type,
+            isIncomplete,
+            isAsymmetricAccessor,
+            narrowedTypeForSet,
+            isRequired,
+            isNotRequired,
+            memberAccessDeprecationInfo,
+            typeErrors,
+        };
     }
     function getTypeOfClassMemberName(errorNode, classType, memberName, usage, diag, flags, selfType, recursionCount = 0) {
         var _a, _b, _c;
@@ -3820,6 +3871,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let type;
         let isTypeIncomplete = false;
+        let narrowedTypeForSet;
         if (memberInfo.symbol.isInitVar()) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.memberIsInitVar().format({ name: memberName }));
             return undefined;
@@ -3842,7 +3894,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) {
@@ -3942,7 +3996,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;
@@ -3971,6 +4026,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return resultType;
         });
         if (!isDescriptorError && usage.method === 'set' && usage.setType) {
+            if (errorNode && memberInfo.symbol.hasTypedDeclarations()) {
+                // This is an assignment to a member with a declared type. Apply
+                // narrowing logic based on the assigned type. Skip this for
+                // descriptor-based accesses.
+                narrowedTypeForSet = isDescriptorApplied
+                    ? usage.setType.type
+                    : narrowTypeBasedOnAssignment(errorNode, type, usage.setType.type);
+            }
             // Verify that the assigned type is compatible.
             if (!assignType(type, usage.setType.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum())) {
                 if (!usage.setType.isIncomplete) {
@@ -3980,6 +4043,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         classType: printObjectTypeForClass(classType),
                     }));
                 }
+                // Do not narrow the type in this case. Assume the declared type.
+                narrowedTypeForSet = type;
                 isDescriptorError = true;
             }
             if ((0, types_1.isInstantiableClass)(memberInfo.classType) &&
@@ -4000,6 +4065,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isClassVar: memberInfo.isClassVar,
             classType: memberInfo.classType,
             isAsymmetricAccessor,
+            narrowedTypeForSet,
             memberAccessDeprecationInfo,
         };
     }
@@ -6620,7 +6686,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;
         }
@@ -6630,7 +6696,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!symbol.isClassMember() && !symbol.isNamedTupleMemberMember()) {
             return undefined;
         }
-        const lastDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+        const lastDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(symbol);
         if (!lastDecl) {
             return undefined;
         }
@@ -6996,7 +7062,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchFunctionArgumentsToParameters(errorNode, argList, typeResult, overloadIndex) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const paramDetails = (0, parameterUtils_1.getParameterListDetails)(typeResult.type);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
@@ -7043,8 +7109,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // function nested within another function that defines the param
                 // spec? We need to handle these two cases differently.
                 const paramSpecScopeId = varArgListParam.type.scopeId;
-                if (paramSpecScopeId === typeResult.type.details.typeVarScopeId ||
-                    paramSpecScopeId === typeResult.type.details.constructorTypeVarScopeId) {
+                if ((_b = (0, typeUtils_1.getTypeVarScopeIds)(typeResult.type)) === null || _b === void 0 ? void 0 : _b.some((id) => id === paramSpecScopeId)) {
                     paramSpecArgList = [];
                     paramSpecTarget = types_1.TypeVarType.cloneForParamSpecAccess(varArgListParam.type, /* access */ undefined);
                 }
@@ -7055,9 +7120,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else if (typeResult.type.details.paramSpec) {
             const paramSpecScopeId = typeResult.type.details.paramSpec.scopeId;
-            if (typeResult.type.details.typeVarScopeId === types_1.WildcardTypeVarScopeId ||
-                paramSpecScopeId === typeResult.type.details.typeVarScopeId ||
-                paramSpecScopeId === typeResult.type.details.constructorTypeVarScopeId) {
+            if ((_c = (0, typeUtils_1.getTypeVarScopeIds)(typeResult.type)) === null || _c === void 0 ? void 0 : _c.some((id) => id === paramSpecScopeId)) {
                 hasParamSpecArgsKwargs = true;
                 paramSpecArgList = [];
                 paramSpecTarget = types_1.TypeVarType.cloneForParamSpecAccess(typeResult.type.details.paramSpec, 
@@ -7149,7 +7212,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
-                                }), (_b = argList[argIndex].valueExpression) !== null && _b !== void 0 ? _b : errorNode);
+                                }), (_d = argList[argIndex].valueExpression) !== null && _d !== void 0 ? _d : errorNode);
                         }
                         reportedArgError = true;
                     }
@@ -7182,7 +7245,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
-                                }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
+                                }), (_e = argList[argIndex].valueExpression) !== null && _e !== void 0 ? _e : errorNode);
                         }
                         reportedArgError = true;
                     }
@@ -7224,9 +7287,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     listElementType = undefined;
                 }
                 else {
-                    listElementType = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
+                    listElementType = (_f = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
                     /* isAsync */ false, errorNode, 
-                    /* emitNotIterableError */ false)) === null || _d === void 0 ? void 0 : _d.type;
+                    /* emitNotIterableError */ false)) === null || _f === void 0 ? void 0 : _f.type;
                     if (paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
@@ -7258,7 +7321,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramType,
                             requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                             argument: funcArg,
-                            errorNode: (_e = argList[argIndex].valueExpression) !== null && _e !== void 0 ? _e : errorNode,
+                            errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
                             paramName,
                             isParamNameSynthesized: paramDetails.params[paramIndex].param.isNameSynthesized,
                             mapsToVarArgList: isParamVariadic && remainingArgCount > remainingParamCount,
@@ -7562,7 +7625,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
-                                    errorNode: (_f = argList[argIndex].valueExpression) !== null && _f !== void 0 ? _f : errorNode,
+                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
                                     paramName: paramNameValue,
                                 });
                                 trySetActive(argList[argIndex], paramDetails.params[paramInfoIndex].param);
@@ -7578,7 +7641,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 paramType,
                                 requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                 argument: argList[argIndex],
-                                errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
+                                errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
                                 paramName: paramNameValue,
                             });
                             // Remember that this parameter has already received a value.
@@ -7628,7 +7691,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
                                     argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
-                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
+                                    errorNode: (_k = argList[argIndex].valueExpression) !== null && _k !== void 0 ? _k : errorNode,
                                 });
                             }
                         }
@@ -7940,12 +8003,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeVarContext.addSolveForScope(type.boundTypeVarScopeId);
                 }
             }
-            // Some typeshed stubs use specialized type annotations in the "self" parameter
-            // of an overloaded __init__ method to specify which specialized type should
-            // be constructed. Although this isn't part of the official Python spec, other
-            // type checkers appear to honor it.
+            // The type annotation for the "self" parameter in an __init__ method to
+            // can incluence the type being constructed.
             if (type.details.name === '__init__' &&
-                types_1.FunctionType.isOverloaded(type) &&
                 type.strippedFirstParamType &&
                 type.boundToType &&
                 (0, types_1.isClassInstance)(type.strippedFirstParamType) &&
@@ -8112,9 +8172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the function is returning a callable, don't eliminate unsolved
         // type vars within a union. There are legit uses for unsolved type vars
         // within a callable.
-        if ((0, types_1.isFunction)(returnType) ||
-            (0, types_1.isOverloadedFunction)(returnType) ||
-            type.details.typeVarScopeId === types_1.WildcardTypeVarScopeId) {
+        if ((0, types_1.isFunction)(returnType) || (0, types_1.isOverloadedFunction)(returnType)) {
             eliminateUnsolvedInUnions = false;
         }
         // We'll leave TypeVars unsolved if the call is a recursive
@@ -8166,7 +8224,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, useTypeIsSemantics));
             }
         }
-        specializedReturnType = adjustCallableReturnType(specializedReturnType, signatureTracker.getTrackedSignatures());
+        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        specializedReturnType = adjustCallableReturnType(type, specializedReturnType, liveTypeVarScopes, signatureTracker.getTrackedSignatures());
         if (specializedInitSelfType) {
             specializedInitSelfType = (0, typeUtils_1.applySolvedTypeVars)(specializedInitSelfType, typeVarContext);
         }
@@ -8209,23 +8268,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return [];
     }
     // If the return type includes a generic Callable type, set the type var
-    // scope to a wildcard to allow these type vars to be solved. This won't
-    // work with overloads or unions of callables. It's intended for a
-    // specific use case. We may need to make this more sophisticated in
-    // the future.
+    // scope to the scope of the function it was originally associated with
+    // to allow these type vars to be solved. This won't work with overloads
+    // or unions of callables. It's intended for a specific use case. We may
+    // need to make this more sophisticated in the future.
     // The trackedSignatures parameter supplies a list of function signatures
     // that were used for the function and the arguments passed to it. This is
     // important because the callable return value may be called again with
     // one of these signatures, so we may need to "uniquify" the type parameters
     // to avoid conflicts.
-    function adjustCallableReturnType(returnType, trackedSignatures) {
-        if ((0, types_1.isFunction)(returnType) && !returnType.details.name) {
-            const typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType);
+    function adjustCallableReturnType(callableType, returnType, liveTypeVarScopes, trackedSignatures) {
+        if ((0, types_1.isFunction)(returnType) && !returnType.details.name && callableType.details.typeVarScopeId) {
+            // What type variables are referenced in the callable return type? Do not include any live type variables.
+            const typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.scopeId === scopeId));
             // If there are no unsolved type variables, we're done. If there are
-            // unsolved type parameters, treat them as though they are rescoped
+            // unsolved type variables, treat them as though they are rescoped
             // to the callable.
             if (typeVarsInReturnType.length > 0) {
-                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, types_1.WildcardTypeVarScopeId, typeVarsInReturnType, trackedSignatures);
+                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, callableType.details.typeVarScopeId, typeVarsInReturnType, trackedSignatures);
             }
         }
         return returnType;
@@ -8493,7 +8553,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isFunction)(concreteParamType) || (0, types_1.isOverloadedFunction)(concreteParamType)) {
                 if ((0, types_1.isInstantiableClass)(argType)) {
                     const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, argType);
-                    if (constructor && (0, types_1.isOverloadedFunction)(constructor)) {
+                    if (constructor) {
                         return {
                             isCompatible,
                             argType,
@@ -8740,7 +8800,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function verifyTypeVarDefaultIsCompatible(typeVar, defaultValueNode) {
         (0, debug_1.assert)(typeVar.details.isDefaultExplicit);
-        const typeVarContext = new typeVarContext_1.TypeVarContext(types_1.WildcardTypeVarScopeId);
+        const typeVarContext = new typeVarContext_1.TypeVarContext(typeVar.scopeId);
         const concreteDefaultType = makeTopLevelTypeVarsConcrete((0, typeUtils_1.applySolvedTypeVars)(typeVar.details.defaultType, typeVarContext, {
             unknownIfNotFound: true,
         }));
@@ -8794,7 +8854,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramName === 'default') {
                     const expr = argList[i].valueExpression;
                     if (expr) {
-                        const defaultType = getTypeVarTupleDefaultType(expr);
+                        const defaultType = getTypeVarTupleDefaultType(expr, /* isPep695Syntax */ false);
                         if (defaultType) {
                             typeVar.details.defaultType = defaultType;
                             typeVar.details.isDefaultExplicit = true;
@@ -8817,10 +8877,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeVar;
     }
-    function getTypeVarTupleDefaultType(node) {
+    function getTypeVarTupleDefaultType(node, isPep695Syntax) {
         const argType = getTypeOfExpressionExpectingType(node, {
             allowUnpackedTuple: true,
             allowTypeVarsWithoutScopeId: true,
+            allowForwardReference: isPep695Syntax,
         }).type;
         const isUnpackedTuple = (0, types_1.isClass)(argType) && (0, typeUtils_1.isTupleClass)(argType) && argType.isUnpacked;
         const isUnpackedTypeVarTuple = (0, types_1.isUnpackedVariadicTypeVar)(argType);
@@ -8853,7 +8914,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramName === 'default') {
                     const expr = argList[i].valueExpression;
                     if (expr) {
-                        const defaultType = getParamSpecDefaultType(expr);
+                        const defaultType = getParamSpecDefaultType(expr, /* isPep695Syntax */ false);
                         if (defaultType) {
                             paramSpec.details.defaultType = defaultType;
                             paramSpec.details.isDefaultExplicit = true;
@@ -8877,7 +8938,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return paramSpec;
     }
-    function getParamSpecDefaultType(node) {
+    function getParamSpecDefaultType(node, isPep695Syntax) {
         const functionType = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
         if (node.nodeType === 18 /* ParseNodeType.Ellipsis */) {
             types_1.FunctionType.addDefaultParameters(functionType);
@@ -8885,7 +8946,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (node.nodeType === 31 /* ParseNodeType.List */) {
             node.entries.forEach((paramExpr, index) => {
-                const typeResult = getTypeOfExpressionExpectingType(paramExpr, { allowTypeVarsWithoutScopeId: true });
+                const typeResult = getTypeOfExpressionExpectingType(paramExpr, {
+                    allowTypeVarsWithoutScopeId: true,
+                    allowForwardReference: isPep695Syntax,
+                });
                 types_1.FunctionType.addParameter(functionType, {
                     category: 0 /* ParameterCategory.Simple */,
                     name: `__p${index}`,
@@ -9109,7 +9173,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, {
@@ -9121,7 +9185,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.addDefaultParameters(newType);
             newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
             newType.details.constructorTypeVarScopeId = classType.details.typeVarScopeId;
-            classType.details.fields.set('__new__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, newType));
+            types_1.ClassType.getSymbolTable(classType).set('__new__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, newType));
         }
         return classType;
     }
@@ -9701,7 +9765,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];
@@ -10051,7 +10115,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;
@@ -10059,8 +10124,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));
@@ -10437,6 +10504,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 else {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'str', value);
                 }
+                itemExpr.strings.forEach((stringNode) => {
+                    if ((stringNode.token.flags & 512 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
+                    }
+                });
             }
             else if (itemExpr.nodeType === 40 /* ParseNodeType.Number */) {
                 if (!itemExpr.isImaginary && itemExpr.isInteger) {
@@ -11054,6 +11126,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) {
@@ -11124,7 +11204,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 }],
@@ -11133,7 +11216,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) {
@@ -11511,6 +11594,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 */ |
@@ -11590,6 +11674,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 */ |
@@ -11948,46 +12033,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.
@@ -12841,7 +12942,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) {
@@ -13751,6 +13857,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         break;
                     }
                 }
+                else if (parent.nodeType === 75 /* ParseNodeType.TypeParameter */) {
+                    // If this is a bound or default expression in a type parameter list,
+                    // we need to evaluate it in the context of the type parameter.
+                    if (node === parent.boundExpression || node === parent.defaultExpression) {
+                        getTypeOfTypeParameter(parent);
+                        return;
+                    }
+                    break;
+                }
                 else {
                     break;
                 }
@@ -15052,6 +15167,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const constraints = node.boundExpression.expressions.map((constraint) => {
                     const constraintType = getTypeOfExpressionExpectingType(constraint, {
                         disallowProtocolAndTypedDict: true,
+                        allowForwardReference: true,
                     }).type;
                     if ((0, typeUtils_1.requiresSpecialization)(constraintType, {
                         ignorePseudoGeneric: true,
@@ -15071,6 +15187,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 const boundType = getTypeOfExpressionExpectingType(node.boundExpression, {
                     disallowProtocolAndTypedDict: true,
+                    allowForwardReference: true,
                 }).type;
                 if ((0, typeUtils_1.requiresSpecialization)(boundType, { ignorePseudoGeneric: true })) {
                     addError(localize_1.LocMessage.typeVarConstraintGeneric(), node.boundExpression);
@@ -15081,7 +15198,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
-            const defaultType = node.defaultExpression ? getParamSpecDefaultType(node.defaultExpression) : undefined;
+            const defaultType = node.defaultExpression
+                ? getParamSpecDefaultType(node.defaultExpression, /* isPep695Syntax */ true)
+                : undefined;
             if (defaultType) {
                 typeVar.details.defaultType = defaultType;
                 typeVar.details.isDefaultExplicit = true;
@@ -15091,7 +15210,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
-            const defaultType = node.defaultExpression ? getTypeVarTupleDefaultType(node.defaultExpression) : undefined;
+            const defaultType = node.defaultExpression
+                ? getTypeVarTupleDefaultType(node.defaultExpression, /* isPep695Syntax */ true)
+                : undefined;
             if (defaultType) {
                 typeVar.details.defaultType = defaultType;
                 typeVar.details.isDefaultExplicit = true;
@@ -15102,7 +15223,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else {
             const defaultType = node.defaultExpression
-                ? (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(node.defaultExpression).type)
+                ? (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(node.defaultExpression, { allowForwardReference: true }).type)
                 : undefined;
             if (defaultType) {
                 typeVar.details.defaultType = defaultType;
@@ -15501,7 +15622,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) {
@@ -15729,7 +15852,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getFunctionEffectiveReturnType(type, args, inferTypeIfNeeded = true) {
         const specializedReturnType = types_1.FunctionType.getSpecializedReturnType(type, /* includeInferred */ false);
         if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
-            return adjustCallableReturnType(specializedReturnType, /* trackedSignatures */ undefined);
+            return adjustCallableReturnType(type, specializedReturnType, /* liveTypeVarScopes */ []);
         }
         if (inferTypeIfNeeded) {
             return getFunctionInferredReturnType(type, args);
@@ -16152,7 +16275,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;
                 }
@@ -16989,7 +17112,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;
@@ -17095,6 +17218,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, concreteSrcType, (0, types_1.isTypeVar)(srcType) ? (0, typeUtils_1.convertToInstance)(srcType) : undefined, recursionCount);
                 if (constructor) {
                     concreteSrcType = constructor;
+                    // The constructor conversion may result in a union of the
+                    // __init__ and __new__ callables.
+                    if ((0, types_1.isUnion)(concreteSrcType)) {
+                        return assignType(destType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                    }
                 }
             }
             if ((0, types_1.isAnyOrUnknown)(concreteSrcType)) {
@@ -17601,11 +17729,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;
                             }
                         }
@@ -18128,10 +18256,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     remainingFunction.details.typeVarScopeId = effectiveSrcType.details.typeVarScopeId;
                     remainingFunction.details.constructorTypeVarScopeId =
                         effectiveSrcType.details.constructorTypeVarScopeId;
+                    remainingFunction.details.methodClass = effectiveSrcType.details.methodClass;
                     remainingParams.forEach((param) => {
                         types_1.FunctionType.addParameter(remainingFunction, param);
                     });
                     remainingFunction.details.paramSpec = srcParamSpec ? (0, typeUtils_1.convertToInstance)(srcParamSpec) : undefined;
+                    types_1.FunctionType.addHigherOrderTypeVarScopeIds(remainingFunction, effectiveSrcType.details.higherOrderTypeVarScopeIds);
                     if (!assignType(destParamSpec, remainingFunction, 
                     /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags)) {
                         // If we couldn't assign the function to the ParamSpec, see if we can
@@ -18162,12 +18292,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (0, typeUtils_1.containsLiteralType)(srcType.details.declaredReturnType, /* includeTypeArgs */ true)) {
                     effectiveFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 }
-                if ((0, types_1.isNever)(srcReturnType)) {
-                    // We'll allow any function that returns NoReturn to match any
-                    // function return type, consistent with other type checkers.
-                    isReturnTypeCompatible = true;
-                }
-                else if (assignType(destReturnType, srcReturnType, returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, effectiveFlags, recursionCount)) {
+                if (assignType(destReturnType, srcReturnType, returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, effectiveFlags, recursionCount)) {
                     isReturnTypeCompatible = true;
                 }
                 else {
@@ -18820,7 +18945,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);
@@ -18840,11 +18965,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // If the memberType is an instance or class method, creates a new
     // version of the function that has the "self" or "cls" parameter bound
-    // to it. If treatConstructorAsClassMember is true, the function is
+    // to it. If treatConstructorAsClassMethod is true, the function is
     // treated like a class method even if it's not marked as such. That's
     // needed to special-case the __new__ magic method when it's invoked as
     // a constructor (as opposed to by name).
-    function bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMember = false, selfType, diag, recursionCount = 0) {
+    function bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMethod = false, selfType, diag, recursionCount = 0) {
         return (0, typeUtils_1.mapSignatures)(memberType, (functionType) => {
             // If the caller specified no base type, always strip the
             // first parameter. This is used in cases like constructors.
@@ -18859,11 +18984,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const baseObj = (0, types_1.isClassInstance)(baseType)
                     ? baseType
                     : types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeClassType)(baseType));
-                return partiallySpecializeFunctionForBoundClassOrObject(baseType, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, selfType !== null && selfType !== void 0 ? selfType : baseObj, 
-                /* stripFirstParam */ (0, types_1.isClassInstance)(baseType));
+                let stripFirstParam = false;
+                if ((0, types_1.isClassInstance)(baseType)) {
+                    stripFirstParam = true;
+                }
+                else if (memberClass && (0, typeUtils_1.isInstantiableMetaclass)(memberClass)) {
+                    stripFirstParam = true;
+                }
+                return partiallySpecializeFunctionForBoundClassOrObject(baseType, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, selfType !== null && selfType !== void 0 ? selfType : baseObj, stripFirstParam);
             }
             if (types_1.FunctionType.isClassMethod(functionType) ||
-                (treatConstructorAsClassMember && types_1.FunctionType.isConstructorMethod(functionType))) {
+                (treatConstructorAsClassMethod && types_1.FunctionType.isConstructorMethod(functionType))) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
                 const clsType = selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : undefined;
                 return partiallySpecializeFunctionForBoundClassOrObject(baseClass, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : baseClass, diag, recursionCount, clsType !== null && clsType !== void 0 ? clsType : baseClass, 
@@ -19069,11 +19200,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 */) {