@zzzen/pyright-internal 1.2.0-dev.20250413 → 1.2.0-dev.20250802

package/dist/analyzer/typeEvaluator.js

@@ -75,6 +75,7 @@ const patternMatching_1 = require("./patternMatching");
 const properties_1 = require("./properties");
 const protocols_1 = require("./protocols");
 const ScopeUtils = __importStar(require("./scopeUtils"));
+const sentinel_1 = require("./sentinel");
 const staticExpressions_1 = require("./staticExpressions");
 const symbol_1 = require("./symbol");
 const symbolNameUtils_1 = require("./symbolNameUtils");
@@ -487,7 +488,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             prefetched = {};
             prefetched.objectClass = getBuiltInType(node, 'object');
             prefetched.typeClass = getBuiltInType(node, 'type');
-            prefetched.functionClass = getBuiltInType(node, 'function');
+            prefetched.functionClass = getTypesType(node, 'FunctionType') ?? getBuiltInType(node, 'function');
+            prefetched.methodClass = getTypesType(node, 'MethodType');
             prefetched.unionTypeClass = getTypesType(node, 'UnionType');
             if (prefetched.unionTypeClass && (0, types_1.isClass)(prefetched.unionTypeClass)) {
                 prefetched.unionTypeClass.shared.flags |= 8388608 /* ClassTypeFlags.SpecialFormClass */;
@@ -503,9 +505,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             prefetched.dictClass = getBuiltInType(node, 'dict');
             prefetched.moduleTypeClass = getTypingType(node, 'ModuleType');
             prefetched.typedDictClass = getTypingType(node, 'TypedDict');
-            prefetched.typedDictPrivateClass = getTypingType(node, '_TypedDict');
+            prefetched.typedDictPrivateClass =
+                getTypeCheckerInternalsType(node, 'TypedDictFallback') ?? getTypingType(node, '_TypedDict');
             prefetched.awaitableClass = getTypingType(node, 'Awaitable');
             prefetched.mappingClass = getTypingType(node, 'Mapping');
+            prefetched.templateClass = getTypeOfModule(node, 'Template', ['string', 'templatelib']);
             prefetched.supportsKeysAndGetItemClass = getTypeshedType(node, 'SupportsKeysAndGetItem');
             if (!prefetched.supportsKeysAndGetItemClass) {
                 // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
@@ -943,7 +947,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const isBytes = firstBytesIndex >= 0;
         let isLiteralString = true;
         let isIncomplete = false;
+        let isTemplate = false;
         node.d.strings.forEach((expr) => {
+            // Handle implicit concatenation.
             const typeResult = getTypeOfString(expr);
             if (typeResult.isIncomplete) {
                 isIncomplete = true;
@@ -956,13 +962,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else if (types_1.ClassType.isBuiltIn(typeResult?.type, 'LiteralString')) {
                     isExprLiteralString = true;
                 }
+                if (typeResult.type.shared.name === 'Template') {
+                    isTemplate = true;
+                }
             }
             if (!isExprLiteralString) {
                 isLiteralString = false;
             }
         });
-        // Don't create a literal type if it's an f-string.
-        if (node.d.strings.some((str) => str.nodeType === 30 /* ParseNodeType.FormatString */)) {
+        if (isTemplate) {
+            const templateType = prefetched?.templateClass && (0, types_1.isInstantiableClass)(prefetched?.templateClass)
+                ? types_1.ClassType.cloneAsInstance(prefetched.templateClass)
+                : types_1.UnknownType.create();
+            typeResult = { type: templateType, isIncomplete };
+        }
+        else if (node.d.strings.some((str) => str.nodeType === 30 /* ParseNodeType.FormatString */)) {
             if (isLiteralString) {
                 const literalStringType = getTypingType(node, 'LiteralString');
                 if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
@@ -992,7 +1006,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // TypeForm (really long, triple-quoted, etc.).
         const stringNode = node.d.strings[0];
         const tokenFlags = stringNode.d.token.flags;
-        const disallowedTokenFlags = 32 /* StringTokenFlags.Bytes */ | 8 /* StringTokenFlags.Raw */ | 64 /* StringTokenFlags.Format */ | 4 /* StringTokenFlags.Triplicate */;
+        const disallowedTokenFlags = 32 /* StringTokenFlags.Bytes */ |
+            8 /* StringTokenFlags.Raw */ |
+            64 /* StringTokenFlags.Format */ |
+            128 /* StringTokenFlags.Template */ |
+            4 /* StringTokenFlags.Triplicate */;
         const maxTypeFormStringLength = 256;
         if ((tokenFlags & disallowedTokenFlags) !== 0 ||
             stringNode.d.token.escapedValue.length >= maxTypeFormStringLength) {
@@ -1037,6 +1055,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 return { type: types_1.UnknownType.create() };
             }
+            if (tokenFlags & 128 /* StringTokenFlags.Template */) {
+                if (reportTypeErrors) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationTemplateString(), node);
+                }
+                return { type: types_1.UnknownType.create() };
+            }
             // 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.
@@ -1059,8 +1083,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const isBytes = (node.d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
         let typeResult;
         let isIncomplete = false;
-        // Don't create a literal type if it's an f-string.
-        if (node.nodeType === 30 /* ParseNodeType.FormatString */) {
+        if (node.nodeType === 49 /* ParseNodeType.String */) {
+            typeResult = {
+                type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.d.value),
+                isIncomplete,
+            };
+        }
+        else {
+            const isTemplateString = (node.d.token.flags & 128 /* StringTokenFlags.Template */) !== 0;
             let isLiteralString = true;
             // If all of the format expressions are of type LiteralString, then
             // the resulting formatted string is also LiteralString.
@@ -1084,7 +1114,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     isLiteralString = false;
                 });
             });
-            if (!isBytes && isLiteralString) {
+            if (isTemplateString) {
+                const templateType = prefetched?.templateClass && (0, types_1.isInstantiableClass)(prefetched?.templateClass)
+                    ? types_1.ClassType.cloneAsInstance(prefetched.templateClass)
+                    : types_1.UnknownType.create();
+                typeResult = { type: templateType, isIncomplete };
+            }
+            else if (!isBytes && isLiteralString) {
                 const literalStringType = getTypingType(node, 'LiteralString');
                 if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
                     typeResult = { type: types_1.ClassType.cloneAsInstance(literalStringType), isIncomplete };
@@ -1100,12 +1136,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        else {
-            typeResult = {
-                type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.d.value),
-                isIncomplete,
-            };
-        }
         return typeResult;
     }
     function stripLiteralValue(type) {
@@ -1205,6 +1235,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (types_1.TypeBase.isInstantiable(type)) {
                     return false;
                 }
+                // Sentinels are always truthy.
+                if ((0, typeUtils_1.isSentinelLiteral)(type)) {
+                    return false;
+                }
                 // Handle tuples specially.
                 if ((0, typeUtils_1.isTupleClass)(type) && type.priv.tupleTypeArgs) {
                     return (0, typeUtils_1.isUnboundedTupleClass)(type) || type.priv.tupleTypeArgs.length === 0;
@@ -1363,6 +1397,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // include, otherwise it should be removed.
                     return isLiteralFalsy ? subtype : undefined;
                 }
+                // If the object is a sentinel, we can eliminate it.
+                if ((0, typeUtils_1.isSentinelLiteral)(concreteSubtype)) {
+                    return undefined;
+                }
                 // If the object is a bool, make it "false", since
                 // "true" is a truthy value.
                 if (types_1.ClassType.isBuiltIn(concreteSubtype, 'bool')) {
@@ -1399,6 +1437,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (concreteSubtype.priv.literalValue instanceof types_1.EnumLiteral) {
                         isLiteralTruthy = !canBeFalsy(concreteSubtype);
                     }
+                    else if (concreteSubtype.priv.literalValue instanceof types_1.SentinelLiteral) {
+                        isLiteralTruthy = true;
+                    }
                     else {
                         isLiteralTruthy = !!concreteSubtype.priv.literalValue;
                     }
@@ -1786,29 +1827,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             case 35 /* ParseNodeType.MemberAccess */: {
                 const baseType = getTypeOfExpression(expression.d.leftExpr, 2 /* EvalFlags.MemberAccessBaseDefaults */).type;
                 const baseTypeConcrete = makeTopLevelTypeVarsConcrete(baseType);
-                let classMemberInfo;
-                if ((0, types_1.isClassInstance)(baseTypeConcrete)) {
-                    classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseTypeConcrete, expression.d.member.d.value, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
-                    classOrObjectBase = baseTypeConcrete;
-                    memberAccessClass = classMemberInfo?.classType;
-                    // If this is an instance member (e.g. a dataclass field), don't
-                    // bind it to the object if it's a function.
-                    if (classMemberInfo?.isInstanceMember) {
+                const memberName = expression.d.member.d.value;
+                // Normally, baseTypeConcrete will not be a composite type (a union),
+                // but this can occur. In this case, it's not clear how to handle this
+                // correctly. For now, we'll just loop through the subtypes and
+                // use one of them. We'll sort the subtypes for determinism.
+                (0, typeUtils_1.doForEachSubtype)(baseTypeConcrete, (baseSubtype) => {
+                    if ((0, types_1.isClassInstance)(baseSubtype)) {
+                        const classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseSubtype, memberName, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                        classOrObjectBase = baseSubtype;
+                        memberAccessClass = classMemberInfo?.classType;
+                        symbol = classMemberInfo?.symbol;
+                        useDescriptorSetterType = true;
+                        // If this is an instance member (e.g. a dataclass field), don't
+                        // bind it to the object if it's a function.
+                        bindFunction = !classMemberInfo?.isInstanceMember;
+                    }
+                    else if ((0, types_1.isInstantiableClass)(baseSubtype)) {
+                        const classMemberInfo = (0, typeUtils_1.lookUpClassMember)(baseSubtype, memberName, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                        classOrObjectBase = baseSubtype;
+                        memberAccessClass = classMemberInfo?.classType;
+                        symbol = classMemberInfo?.symbol;
+                        useDescriptorSetterType = false;
+                        bindFunction = true;
+                    }
+                    else if ((0, types_1.isModule)(baseSubtype)) {
+                        classOrObjectBase = undefined;
+                        memberAccessClass = undefined;
+                        symbol = types_1.ModuleType.getField(baseSubtype, memberName);
+                        if (symbol && !symbol.hasTypedDeclarations()) {
+                            // Do not use inferred types for the declared type.
+                            symbol = undefined;
+                        }
+                        useDescriptorSetterType = false;
                         bindFunction = false;
                     }
-                    useDescriptorSetterType = true;
-                }
-                else if ((0, types_1.isInstantiableClass)(baseTypeConcrete)) {
-                    classMemberInfo = (0, typeUtils_1.lookUpClassMember)(baseTypeConcrete, expression.d.member.d.value, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 64 /* MemberAccessFlags.DeclaredTypesOnly */);
-                    classOrObjectBase = baseTypeConcrete;
-                    memberAccessClass = classMemberInfo?.classType;
-                }
+                }, 
+                /* sortSubtypes */ true);
                 if ((0, types_1.isTypeVar)(baseType)) {
                     selfType = baseType;
                 }
-                if (classMemberInfo) {
-                    symbol = classMemberInfo.symbol;
-                }
                 break;
             }
             case 27 /* ParseNodeType.Index */: {
@@ -1850,6 +1908,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 break;
             }
+            case 52 /* ParseNodeType.Tuple */: {
+                // If this is a tuple expression with at least one item and no
+                // unpacked items, and all of the items have declared types,
+                // we can assume a declared type for the resulting tuple. This
+                // is needed to enable bidirectional type inference when assigning
+                // to an unpacked tuple.
+                if (expression.d.items.length > 0 &&
+                    !expression.d.items.some((item) => item.nodeType === 56 /* ParseNodeType.Unpack */)) {
+                    const itemTypes = [];
+                    expression.d.items.forEach((expr) => {
+                        const itemType = getDeclaredTypeForExpression(expr, usage);
+                        if (itemType) {
+                            itemTypes.push(itemType);
+                        }
+                    });
+                    if (itemTypes.length === expression.d.items.length) {
+                        // If all items have a declared type, return a tuple of those types.
+                        return (0, tuples_1.makeTupleObject)(evaluatorInterface, itemTypes.map((t) => {
+                            return { type: t, isUnbounded: false };
+                        }));
+                    }
+                }
+                break;
+            }
         }
         if (symbol) {
             let declaredType = getDeclaredTypeOfSymbol(symbol)?.type;
@@ -2116,6 +2198,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypingType(node, symbolName) {
         return (getTypeOfModule(node, symbolName, ['typing']) ?? getTypeOfModule(node, symbolName, ['typing_extensions']));
     }
+    function getTypeCheckerInternalsType(node, symbolName) {
+        return getTypeOfModule(node, symbolName, ['_typeshed', '_type_checker_internals']);
+    }
     function getTypesType(node, symbolName) {
         return getTypeOfModule(node, symbolName, ['types']);
     }
@@ -2166,7 +2251,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (node.parent) {
                 return getNodeReachability(node.parent, sourceNode);
             }
-            return typeEvaluatorTypes_1.Reachability.UnreachableAlways;
+            return typeEvaluatorTypes_1.Reachability.UnreachableStructural;
         }
         const sourceFlowNode = sourceNode ? AnalyzerNodeInfo.getFlowNode(sourceNode) : undefined;
         return codeFlowEngine.getFlowNodeReachability(flowNode, sourceFlowNode);
@@ -2174,7 +2259,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getAfterNodeReachability(node) {
         const returnFlowNode = AnalyzerNodeInfo.getAfterFlowNode(node);
         if (!returnFlowNode) {
-            return typeEvaluatorTypes_1.Reachability.UnreachableAlways;
+            return typeEvaluatorTypes_1.Reachability.UnreachableStructural;
         }
         if (checkCodeFlowTooComplex(node)) {
             return typeEvaluatorTypes_1.Reachability.Reachable;
@@ -2183,7 +2268,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (reachability !== typeEvaluatorTypes_1.Reachability.Reachable) {
             return reachability;
         }
-        if (!isFlowNodeReachableUsingNeverNarrowing(node, returnFlowNode)) {
+        const executionScopeNode = ParseTreeUtils.getExecutionScopeNode(node);
+        if (!isFlowNodeReachableUsingNeverNarrowing(executionScopeNode, returnFlowNode)) {
             return typeEvaluatorTypes_1.Reachability.UnreachableByAnalysis;
         }
         return typeEvaluatorTypes_1.Reachability.Reachable;
@@ -2191,7 +2277,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Although isFlowNodeReachable indicates that the node is reachable, it
     // may not be reachable if we apply "never narrowing".
     function isFlowNodeReachableUsingNeverNarrowing(node, flowNode) {
-        const analyzer = getCodeFlowAnalyzerForNode(node.id, /* typeAtStart */ undefined);
+        const analyzer = getCodeFlowAnalyzerForNode(node, /* typeAtStart */ undefined);
         if (checkCodeFlowTooComplex(node)) {
             return true;
         }
@@ -2219,12 +2305,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function addInformation(message, node, range) {
         return addDiagnosticWithSuppressionCheck('information', message, node, range);
     }
-    function addUnusedCode(node, textRange) {
-        if (!isDiagnosticSuppressedForNode(node)) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unreachableCode(), textRange);
-        }
-    }
     function addUnreachableCode(node, reachability, textRange) {
         if (reachability === typeEvaluatorTypes_1.Reachability.Reachable) {
             return;
@@ -2232,10 +2312,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!isDiagnosticSuppressedForNode(node)) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
             const reportTypeReachability = fileInfo.diagnosticRuleSet.enableReachabilityAnalysis;
-            if (reachability === typeEvaluatorTypes_1.Reachability.UnreachableAlways || reportTypeReachability) {
-                fileInfo.diagnosticSink.addUnreachableCodeWithTextRange(reachability === typeEvaluatorTypes_1.Reachability.UnreachableAlways
-                    ? localize_1.LocMessage.unreachableCode()
-                    : localize_1.LocMessage.unreachableCodeType(), textRange);
+            if (reachability === typeEvaluatorTypes_1.Reachability.UnreachableStructural ||
+                reachability === typeEvaluatorTypes_1.Reachability.UnreachableStaticCondition ||
+                reportTypeReachability) {
+                fileInfo.diagnosticSink.addUnreachableCodeWithTextRange(reachability === typeEvaluatorTypes_1.Reachability.UnreachableStructural
+                    ? localize_1.LocMessage.unreachableCodeStructure()
+                    : reachability === typeEvaluatorTypes_1.Reachability.UnreachableStaticCondition
+                        ? localize_1.LocMessage.unreachableCodeCondition()
+                        : localize_1.LocMessage.unreachableCodeType(), textRange);
             }
         }
     }
@@ -2652,7 +2736,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // If the type includes promotion types, expand these to their constituent types.
     function expandPromotionTypes(node, type, excludeBytes = false) {
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
-            if (!(0, types_1.isClass)(subtype) || !subtype.priv.includePromotions) {
+            if (!(0, types_1.isClass)(subtype) || !subtype.priv.includePromotions || subtype.priv.literalValue !== undefined) {
                 return subtype;
             }
             if (excludeBytes && types_1.ClassType.isBuiltIn(subtype, 'bytes')) {
@@ -3226,6 +3310,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 type = types_1.UnknownType.create();
             }
         }
+        // If we're expecting a type expression and got a sentinel literal instance,
+        // treat it as its instantiable counterpart. This is similar to how None
+        // is treated in a type expression context.
+        if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0 && (0, types_1.isClassInstance)(type) && (0, typeUtils_1.isSentinelLiteral)(type)) {
+            type = types_1.ClassType.cloneAsInstantiable(type);
+        }
         type = convertSpecialFormToRuntimeValue(type, flags);
         if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
             reportUseOfTypeCheckOnly(type, node);
@@ -3299,6 +3389,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isClass)(type) && !type.priv.includeSubclasses && types_1.ClassType.isValidTypeAliasClass(type)) {
             return true;
         }
+        if ((0, typeUtils_1.isSentinelLiteral)(type)) {
+            return true;
+        }
         return false;
     }
     // Reports diagnostics if type isn't valid within a type expression.
@@ -3332,7 +3425,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Isinstance treats traditional (non-PEP 695) type aliases that are unions
         // as tuples of classes rather than unions.
         if ((flags & 536870912 /* EvalFlags.IsinstanceArg */) !== 0) {
-            if ((0, types_1.isUnion)(type) && type.props?.typeAliasInfo && !type.props.typeAliasInfo.shared.isPep695Syntax) {
+            if ((0, types_1.isUnion)(type) && type.props?.typeAliasInfo && !type.props.typeAliasInfo.shared.isTypeAliasType) {
                 return type;
             }
         }
@@ -3861,6 +3954,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             case 6 /* TypeCategory.Class */: {
                 let typeResult;
+                // If this is a class-like function created via NewType, treat
+                // it like a function for purposes of member accesses.
+                if (types_1.ClassType.isNewTypeClass(baseType) &&
+                    !baseType.priv.includeSubclasses &&
+                    prefetched?.functionClass &&
+                    (0, types_1.isClass)(prefetched.functionClass)) {
+                    baseType = types_1.ClassType.cloneAsInstance(prefetched.functionClass);
+                }
                 const enumMemberResult = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete);
                 if (enumMemberResult) {
                     if (usage.method === 'get') {
@@ -4019,9 +4120,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             case 4 /* TypeCategory.Function */:
             case 5 /* TypeCategory.Overloaded */: {
-                if (memberName === '__self__') {
-                    // The "__self__" member is not currently defined in the "function"
-                    // class, so we'll special-case it here.
+                const hasSelf = (0, types_1.isMethodType)(baseType);
+                if (memberName === '__self__' && hasSelf) {
+                    // Handle "__self__" specially because MethodType defines
+                    // it simply as "object". We can do better here.
                     let functionType;
                     if ((0, types_1.isFunction)(baseType)) {
                         functionType = baseType;
@@ -4032,18 +4134,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             functionType = overloads[0];
                         }
                     }
-                    if (functionType &&
-                        functionType.priv.preBoundFlags !== undefined &&
-                        (functionType.priv.preBoundFlags & 4 /* FunctionTypeFlags.StaticMethod */) === 0) {
-                        type = functionType.priv.boundToType;
-                    }
+                    type = functionType?.priv.boundToType;
                 }
                 else {
-                    type = getTypeOfMemberAccessWithBaseType(node, {
-                        type: prefetched?.functionClass
-                            ? (0, typeUtils_1.convertToInstance)(prefetched.functionClass)
-                            : types_1.UnknownType.create(),
-                    }, usage, flags).type;
+                    const altType = hasSelf ? prefetched?.methodClass : prefetched?.functionClass;
+                    type = getTypeOfMemberAccessWithBaseType(node, { type: altType ? (0, typeUtils_1.convertToInstance)(altType) : types_1.UnknownType.create() }, usage, flags).type;
                 }
                 break;
             }
@@ -4054,7 +4149,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // member could not be accessed.
         if (!type) {
             const isFunctionRule = (0, types_1.isFunctionOrOverloaded)(baseType) ||
-                ((0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, 'function'));
+                ((0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, ['function', 'FunctionType']));
             if (!baseTypeResult.isIncomplete) {
                 let diagMessage = localize_1.LocMessage.memberAccess();
                 if (usage.method === 'set') {
@@ -4066,7 +4161,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If there is an expected type diagnostic addendum (used for assignments),
                 // use that rather than the local diagnostic addendum because it will be
                 // more informative.
-                if (usage.setExpectedTypeDiag) {
+                if (usage.setExpectedTypeDiag && !usage.setExpectedTypeDiag.isEmpty()) {
                     diag = usage.setExpectedTypeDiag;
                 }
                 // If the class is a TypedDict, and there's a key with the same name,
@@ -4229,7 +4324,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let memberAccessDeprecationInfo;
         type = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
-            const isClassMember = !memberInfo || memberInfo.isClassMember;
+            const isClassMember = !memberInfo || (memberInfo.isClassMember && !memberInfo.isSlotsMember);
             let resultType;
             if ((0, types_1.isClass)(concreteSubtype) && isClassMember && errorNode) {
                 const descResult = applyDescriptorAccessMethod(subtype, concreteSubtype, memberInfo, classType, selfType, flags, errorNode, memberName, usage, diag);
@@ -4294,7 +4389,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 isDescriptorError = true;
             }
             return resultType;
-        });
+        }, { retainTypeAlias: true });
         if (!isDescriptorError && usage.method === 'set' && usage.setType) {
             if (errorNode && memberInfo.symbol.hasTypedDeclarations()) {
                 // This is an assignment to a member with a declared type. Apply
@@ -6182,31 +6277,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             secondArgType = getTypeOfExpression(node.d.args[1].d.valueExpr).type;
             const secondArgConcreteType = makeTopLevelTypeVarsConcrete(secondArgType);
             let reportError = false;
-            if ((0, types_1.isAnyOrUnknown)(secondArgConcreteType)) {
-                // Ignore unknown or any types.
-            }
-            else if ((0, types_1.isClassInstance)(secondArgConcreteType)) {
-                if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
-                    if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(secondArgConcreteType), concreteTargetClassType, 
-                    /* ignoreUnknown */ true)) {
-                        reportError = true;
-                    }
+            (0, typeUtils_1.doForEachSubtype)(secondArgConcreteType, (secondArgSubtype) => {
+                if ((0, types_1.isAnyOrUnknown)(secondArgSubtype)) {
+                    // Ignore unknown or any types.
                 }
-                bindToType = secondArgConcreteType;
-            }
-            else if ((0, types_1.isInstantiableClass)(secondArgConcreteType)) {
-                if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
-                    if (!types_1.ClassType.isBuiltIn(concreteTargetClassType, 'type') &&
-                        !(0, typeUtils_1.derivesFromClassRecursive)(secondArgConcreteType, concreteTargetClassType, 
+                else if ((0, types_1.isClassInstance)(secondArgSubtype)) {
+                    if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
+                        if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(secondArgSubtype), concreteTargetClassType, 
                         /* ignoreUnknown */ true)) {
-                        reportError = true;
+                            reportError = true;
+                        }
                     }
+                    bindToType = secondArgSubtype;
                 }
-                bindToType = secondArgConcreteType;
-            }
-            else {
-                reportError = true;
-            }
+                else if ((0, types_1.isInstantiableClass)(secondArgSubtype)) {
+                    if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
+                        if (!types_1.ClassType.isBuiltIn(concreteTargetClassType, 'type') &&
+                            !(0, typeUtils_1.derivesFromClassRecursive)(secondArgSubtype, concreteTargetClassType, 
+                            /* ignoreUnknown */ true)) {
+                            reportError = true;
+                        }
+                    }
+                    bindToType = secondArgSubtype;
+                }
+                else {
+                    reportError = true;
+                }
+            });
             if (reportError) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.superCallSecondArg().format({ type: printType(targetClassType) }), node.d.args[1].d.valueExpr);
                 return { type: types_1.UnknownType.create() };
@@ -7137,6 +7234,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             return subtype;
                         }
                         if ((0, types_1.isClass)(subtype)) {
+                            // Specifically handle the case where the subtype is a class-like
+                            // object created by calling NewType. At runtime, it's actually
+                            // a FunctionType object.
+                            if ((0, types_1.isClassInstance)(subtype) &&
+                                types_1.ClassType.isNewTypeClass(subtype) &&
+                                !subtype.priv.includeSubclasses) {
+                                if (prefetched?.functionClass) {
+                                    return prefetched.functionClass;
+                                }
+                            }
                             return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
                         }
                         if (types_1.TypeBase.isInstance(subtype)) {
@@ -7198,6 +7305,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (className === 'NewType') {
                 return { returnType: createNewType(errorNode, argList) };
             }
+            // Handle the Sentinel call specially.
+            if (className === 'Sentinel') {
+                if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
+                    return { returnType: (0, sentinel_1.createSentinelType)(evaluatorInterface, errorNode, argList) };
+                }
+            }
             if (types_1.ClassType.isSpecialFormClass(expandedCallType)) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeNotIntantiable().format({ type: className }), errorNode);
                 return { returnType: types_1.UnknownType.create(), argumentErrors: true };
@@ -9348,7 +9461,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         return getTypeOfTypeAliasCommon(nameNode, nameNode, valueExpr, 
-        /* isPep695Syntax */ true, 
+        /* isPep695Syntax */ false, 
         /* typeParamNodes */ undefined, () => typeParams);
     }
     function getBooleanValue(node) {
@@ -9433,13 +9546,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!isBaseClassAny) {
             // Synthesize an __init__ method that accepts only the specified type.
             const initType = types_1.FunctionType.createSynthesizedInstance('__init__');
-            types_1.FunctionType.addParam(initType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, types_1.ClassType.cloneAsInstance(classType), types_1.FunctionParamFlags.TypeDeclared, 'self'));
+            types_1.FunctionType.addParam(initType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, types_1.AnyType.create(), types_1.FunctionParamFlags.TypeDeclared, 'self'));
             types_1.FunctionType.addParam(initType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, types_1.ClassType.cloneAsInstance(baseClass), types_1.FunctionParamFlags.TypeDeclared, '_x'));
             initType.shared.declaredReturnType = getNoneType();
             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.addParam(newType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, classType, types_1.FunctionParamFlags.TypeDeclared, 'cls'));
+            types_1.FunctionType.addParam(newType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, types_1.AnyType.create(), types_1.FunctionParamFlags.TypeDeclared, 'cls'));
             types_1.FunctionType.addDefaultParams(newType);
             newType.shared.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
             newType.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
@@ -10876,7 +10989,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                     itemExpr.d.strings.forEach((stringNode) => {
-                        if ((stringNode.d.token.flags & 512 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
+                        if ((stringNode.d.token.flags & 1024 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
                             isValidTypeForm = false;
                         }
@@ -11545,7 +11658,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 names: variadics.map((v) => `"${v.shared.name}"`).join(', '),
             }), errorNode);
         }
-        if (!sharedInfo.isPep695Syntax && !isPep695TypeVarType) {
+        if (!sharedInfo.isTypeAliasType && !isPep695TypeVarType) {
             const boundTypeVars = typeParams.filter((typeVar) => typeVar.priv.scopeId !== sharedInfo.typeVarScopeId &&
                 typeVar.priv.scopeType === 0 /* TypeVarScopeType.Class */);
             if (boundTypeVars.length > 0) {
@@ -11564,7 +11677,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         // All PEP 695 type aliases are special forms because they are
         // TypeAliasType objects at runtime.
-        if (sharedInfo.isPep695Syntax || isPep695TypeVarType) {
+        if (sharedInfo.isTypeAliasType || isPep695TypeVarType) {
             const typeAliasTypeClass = getTypingType(errorNode, 'TypeAliasType');
             if (typeAliasTypeClass && (0, types_1.isInstantiableClass)(typeAliasTypeClass)) {
                 typeAlias = types_1.TypeBase.cloneAsSpecialForm(typeAlias, types_1.ClassType.cloneAsInstance(typeAliasTypeClass));
@@ -11618,7 +11731,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // The _TypedDict class is marked as abstract, but the
                 // methods that are abstract are overridden and shouldn't
                 // cause the TypedDict to be marked as abstract.
-                if ((0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, '_TypedDict')) {
+                if ((0, types_1.isInstantiableClass)(baseClass) &&
+                    types_1.ClassType.isBuiltIn(baseClass, ['_TypedDict', 'TypedDictFallback'])) {
                     baseClass = types_1.ClassType.cloneWithNewFlags(baseClass, baseClass.shared.flags &
                         ~(64 /* ClassTypeFlags.SupportsAbstractMethods */ | 1048576 /* ClassTypeFlags.TypeCheckOnly */));
                 }
@@ -11840,7 +11954,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if (typeAliasNameNode) {
-                typeAliasPlaceholder = synthesizeTypeAliasPlaceholder(typeAliasNameNode, /* isPep695Syntax */ false);
+                typeAliasPlaceholder = synthesizeTypeAliasPlaceholder(typeAliasNameNode);
                 writeTypeCache(node, { type: typeAliasPlaceholder }, /* flags */ undefined);
                 writeTypeCache(node.d.leftExpr, { type: typeAliasPlaceholder }, /* flags */ undefined);
                 if (node.d.leftExpr.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
@@ -11900,7 +12014,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Synthesize a TypeVar that acts as a placeholder for a type alias. This allows
     // the type alias definition to refer to itself.
-    function synthesizeTypeAliasPlaceholder(nameNode, isPep695Syntax) {
+    function synthesizeTypeAliasPlaceholder(nameNode, isTypeAliasType = false) {
         const placeholder = types_1.TypeVarType.createInstantiable(`__type_alias_${nameNode.d.value}`);
         placeholder.shared.isSynthesized = true;
         const typeVarScopeId = ParseTreeUtils.getScopeIdForNode(nameNode);
@@ -11911,7 +12025,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             moduleName: fileInfo.moduleName,
             fileUri: fileInfo.fileUri,
             typeVarScopeId,
-            isPep695Syntax,
+            isTypeAliasType,
             typeParams: undefined,
             computedVariance: undefined,
         };
@@ -11939,7 +12053,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Synthesize a type variable that represents the type alias while we're
         // evaluating it. This allows us to handle recursive definitions.
-        const typeAliasTypeVar = synthesizeTypeAliasPlaceholder(nameNode, isPep695Syntax);
+        const typeAliasTypeVar = synthesizeTypeAliasPlaceholder(nameNode, /* isTypeAliasType */ true);
         // Write the type to the type cache to support recursive type alias definitions.
         writeTypeCache(nameNode, { type: typeAliasTypeVar }, /* flags */ undefined);
         // Set a partial type to handle recursive (self-referential) type aliases.
@@ -11953,10 +12067,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (typeAliasTypeVar.shared.recursiveAlias) {
             typeAliasTypeVar.shared.recursiveAlias.typeParams = typeParams ?? [];
         }
-        const aliasTypeResult = getTypeOfExpressionExpectingType(valueNode, {
-            forwardRefs: true,
-            typeExpression: true,
-        });
+        let aliasTypeResult;
+        if (isPep695Syntax) {
+            aliasTypeResult = getTypeOfExpressionExpectingType(valueNode, {
+                forwardRefs: true,
+                typeExpression: true,
+            });
+        }
+        else {
+            const flags = 128 /* EvalFlags.InstantiableType */ |
+                256 /* EvalFlags.TypeExpression */ |
+                8 /* EvalFlags.StrLiteralAsType */ |
+                32 /* EvalFlags.NoParamSpec */ |
+                64 /* EvalFlags.NoTypeVarTuple */ |
+                131072 /* EvalFlags.NoClassVar */;
+            aliasTypeResult = getTypeOfExpression(valueNode, flags);
+        }
         let isIncomplete = false;
         let aliasType = aliasTypeResult.type;
         if (aliasTypeResult.isIncomplete) {
@@ -12058,8 +12184,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (fileInfo.isStubFile) {
             classFlags |= 262144 /* ClassTypeFlags.DefinedInStub */;
         }
-        const classType = types_1.ClassType.createInstantiable(node.d.name.d.value, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, node.d.name.d.value), fileInfo.moduleName, fileInfo.fileUri, classFlags, 
-        /* typeSourceId */ 0, 
+        const classType = types_1.ClassType.createInstantiable(node.d.name.d.value, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, node.d.name.d.value), fileInfo.moduleName, fileInfo.fileUri, classFlags, ParseTreeUtils.getTypeSourceId(node), 
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined, ParseTreeUtils.getDocString(node.d.suite.d.statements));
         classType.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
@@ -12231,11 +12356,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                         // Determine if the class is abstract. Protocol classes support abstract methods
                         // because they are constructed by the _ProtocolMeta metaclass, which derives
-                        // from ABCMeta. We'll exclude built-in protocol classes because these are known
-                        // not to contain any abstract methods and getAbstractMethods causes problems
-                        // because of dependencies on some of these built-in protocol classes.
-                        if (types_1.ClassType.supportsAbstractMethods(argType) ||
-                            (types_1.ClassType.isProtocolClass(argType) && !types_1.ClassType.isBuiltIn(argType))) {
+                        // from ABCMeta.
+                        if (types_1.ClassType.supportsAbstractMethods(argType) || types_1.ClassType.isProtocolClass(argType)) {
                             classType.shared.flags |= 64 /* ClassTypeFlags.SupportsAbstractMethods */;
                         }
                         if (types_1.ClassType.isPropertyClass(argType)) {
@@ -12386,8 +12508,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else if (variadics.length > 0) {
                 // Make sure a TypeVar with a default doesn't come after a TypeVarTuple.
-                const firstVariadicIndex = classType.shared.typeParams.findIndex((param) => (0, types_1.isTypeVarTuple)(param));
-                const typeVarWithDefaultIndex = classType.shared.typeParams.findIndex((param, index) => index > firstVariadicIndex && !(0, types_1.isParamSpec)(param) && param.shared.isDefaultExplicit);
+                const firstVariadicIndex = typeParams.findIndex((param) => (0, types_1.isTypeVarTuple)(param));
+                const typeVarWithDefaultIndex = typeParams.findIndex((param, index) => index > firstVariadicIndex && !(0, types_1.isParamSpec)(param) && param.shared.isDefaultExplicit);
                 if (typeVarWithDefaultIndex >= 0) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarWithDefaultFollowsVariadic().format({
                         typeVarName: typeParams[typeVarWithDefaultIndex].shared.name,
@@ -12551,7 +12673,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 classType.shared.baseClasses.forEach((baseClass) => {
                     if ((0, types_1.isClass)(baseClass) &&
                         !types_1.ClassType.isTypedDictClass(baseClass) &&
-                        !types_1.ClassType.isBuiltIn(baseClass, ['_TypedDict', 'Generic'])) {
+                        !types_1.ClassType.isBuiltIn(baseClass, ['_TypedDict', 'TypedDictFallback', 'Generic'])) {
                         foundInvalidBaseClass = true;
                         diag.addMessage(localize_1.LocAddendum.typedDictBaseClass().format({ type: baseClass.shared.name }));
                     }
@@ -13472,11 +13594,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function inferParamTypeFromDefaultValue(paramValueExpr) {
         const defaultValueType = getTypeOfExpression(paramValueExpr, 1 /* EvalFlags.ConvertEllipsisToAny */).type;
         let inferredParamType;
-        // Is the default value a "None" or an instance of some private class (one
-        // whose name starts with an underscore)? If so, we will assume that the
-        // value is a singleton sentinel. The actual supported type is going to be
-        // a union of this type and Unknown.
+        // Is the default value a "None", a sentinel, or an instance of some private
+        // class (one whose name starts with an underscore)? If so, we will assume
+        // that the value is a singleton sentinel. The actual supported type is
+        // going to be a union of this type and Unknown.
         if ((0, typeUtils_1.isNoneInstance)(defaultValueType) ||
+            (0, typeUtils_1.isSentinelLiteral)(defaultValueType) ||
             ((0, types_1.isClassInstance)(defaultValueType) && (0, symbolNameUtils_1.isPrivateOrProtectedName)(defaultValueType.shared.name))) {
             inferredParamType = (0, types_1.combineTypes)([defaultValueType, types_1.UnknownType.create()]);
         }
@@ -13748,7 +13871,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         const inferredYieldType = (0, types_1.combineTypes)(inferredYieldTypes);
                         // Inferred yield types need to be wrapped in a Generator or
                         // AwaitableGenerator to produce the final result.
-                        const generatorType = getTypingType(node, useAwaitableGenerator ? 'AwaitableGenerator' : 'Generator');
+                        const generatorType = useAwaitableGenerator
+                            ? getTypeCheckerInternalsType(node, 'AwaitableGenerator') ??
+                                getTypingType(node, 'AwaitableGenerator')
+                            : getTypingType(node, 'Generator');
                         if (generatorType && (0, types_1.isInstantiableClass)(generatorType)) {
                             const typeArgs = [];
                             // The "send type" for the generator (the second type argument) is
@@ -14688,8 +14814,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
-    function getCodeFlowAnalyzerForNode(nodeId, typeAtStart) {
-        let entries = codeFlowAnalyzerCache.get(nodeId);
+    function getCodeFlowAnalyzerForNode(node, typeAtStart) {
+        let entries = codeFlowAnalyzerCache.get(node.id);
         if (entries) {
             const cachedEntry = entries.find((entry) => {
                 if (!typeAtStart || !entry.typeAtStart) {
@@ -14711,7 +14837,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else {
             entries = [{ typeAtStart, codeFlowAnalyzer: analyzer }];
-            codeFlowAnalyzerCache.set(nodeId, entries);
+            codeFlowAnalyzerCache.set(node.id, entries);
         }
         return analyzer;
     }
@@ -14747,7 +14873,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             analyzer = getCodeFlowAnalyzerForReturnTypeInferenceContext();
         }
         else {
-            analyzer = getCodeFlowAnalyzerForNode(executionNode.id, options?.typeAtStart);
+            analyzer = getCodeFlowAnalyzerForNode(executionNode, options?.typeAtStart);
         }
         const flowNode = AnalyzerNodeInfo.getFlowNode(startNode ?? reference);
         if (flowNode === undefined) {
@@ -15737,7 +15863,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const classTypeInfo = getTypeOfClass(classNode);
                     return {
                         type: classTypeInfo
-                            ? (0, typeUtils_1.synthesizeTypeVarForSelfCls)(classTypeInfo.classType, /* isClsParam */ true)
+                            ? types_1.TypeVarType.cloneAsBound((0, typeUtils_1.synthesizeTypeVarForSelfCls)(classTypeInfo.classType, /* isClsParam */ true))
                             : types_1.UnknownType.create(),
                     };
                 }
@@ -16157,8 +16283,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // in the event that its inferred type is instantiable or explicitly Any
                 // (but not an ellipsis).
                 if (isLegalImplicitTypeAliasType(inferredType)) {
-                    const typeAliasTypeVar = synthesizeTypeAliasPlaceholder(resolvedDecl.typeAliasName, 
-                    /* isPep695Syntax */ false);
+                    const typeAliasTypeVar = synthesizeTypeAliasPlaceholder(resolvedDecl.typeAliasName);
                     inferredType = transformTypeForTypeAlias(inferredType, resolvedDecl.node, typeAliasTypeVar, 
                     /* isPep695TypeVarType */ false);
                     isUnambiguousType = true;
@@ -16952,7 +17077,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (errorNode &&
             selfClass &&
             (0, types_1.isClass)(selfClass) &&
-            !selfClass.priv.includeSubclasses &&
             member.isInstanceMember &&
             (0, types_1.isClass)(member.unspecializedClassType) &&
             (flags & 1024 /* MemberAccessFlags.DisallowGenericInstanceVariableAccess */) !== 0 &&
@@ -17421,6 +17545,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
+        // If the source is a class-like type created by a call to NewType, treat it
+        // as a FunctionClass instance rather than an instantiable class for
+        // purposes of assignability. This reflects its actual runtime type.
+        if ((0, types_1.isInstantiableClass)(srcType) && types_1.ClassType.isNewTypeClass(srcType) && !srcType.priv.includeSubclasses) {
+            if (prefetched?.functionClass && (0, types_1.isInstantiableClass)(prefetched?.functionClass)) {
+                srcType = types_1.ClassType.cloneAsInstance(prefetched.functionClass);
+            }
+        }
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return true;
         }
@@ -17748,16 +17880,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     concreteSrcType.priv.tupleTypeArgs) {
                     return assignType(destType, (0, typeUtils_1.combineTupleTypeArgs)(concreteSrcType.priv.tupleTypeArgs), diag, constraints, flags, recursionCount);
                 }
-                // Handle enum literals that are assignable to another (non-Enum) literal.
-                // This can happen for IntEnum and StrEnum members.
-                if (types_1.ClassType.isEnumClass(concreteSrcType) &&
-                    concreteSrcType.priv.literalValue instanceof types_1.EnumLiteral &&
-                    concreteSrcType.shared.mro.some((base) => (0, types_1.isClass)(base) && types_1.ClassType.isBuiltIn(base, ['int', 'str', 'bytes'])) &&
-                    (0, types_1.isClassInstance)(concreteSrcType.priv.literalValue.itemType) &&
-                    (0, typeUtils_1.isLiteralType)(concreteSrcType.priv.literalValue.itemType) &&
-                    assignType(destType, concreteSrcType.priv.literalValue.itemType)) {
-                    return true;
-                }
                 if (destType.priv.literalValue !== undefined &&
                     types_1.ClassType.isSameGenericClass(destType, concreteSrcType)) {
                     const srcLiteral = concreteSrcType.priv.literalValue;
@@ -17797,9 +17919,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (destCallbackType) {
                     return assignType(destCallbackType, concreteSrcType, diag, constraints, flags, recursionCount);
                 }
-                // All functions are considered instances of "builtins.function".
-                if (prefetched?.functionClass) {
-                    return assignType(destType, (0, typeUtils_1.convertToInstance)(prefetched.functionClass), diag, constraints, flags, recursionCount);
+                // All functions are considered instances of "types.FunctionType" or "types.MethodType".
+                const altClass = (0, types_1.isMethodType)(concreteSrcType) ? prefetched?.methodClass : prefetched?.functionClass;
+                if (altClass) {
+                    return assignType(destType, (0, typeUtils_1.convertToInstance)(altClass), diag, constraints, flags, recursionCount);
                 }
             }
             else if ((0, types_1.isModule)(concreteSrcType)) {
@@ -18742,8 +18865,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (srcParamSpec) {
             srcType = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(srcType);
         }
-        const destParamDetails = (0, parameterUtils_1.getParamListDetails)(destType);
-        const srcParamDetails = (0, parameterUtils_1.getParamListDetails)(srcType);
+        const destParamDetails = (0, parameterUtils_1.getParamListDetails)(destType, {
+            disallowExtraKwargsForTd: (flags & 131072 /* AssignTypeFlags.DisallowExtraKwargsForTd */) !== 0,
+        });
+        const srcParamDetails = (0, parameterUtils_1.getParamListDetails)(srcType, {
+            disallowExtraKwargsForTd: (flags & 131072 /* AssignTypeFlags.DisallowExtraKwargsForTd */) !== 0,
+        });
         adjustSourceParamDetailsForDestVariadic(isContra ? destParamDetails : srcParamDetails, isContra ? srcParamDetails : destParamDetails);
         const targetIncludesParamSpec = isContra ? !!srcParamSpec : !!destParamSpec;
         const destPositionalCount = destParamDetails.firstKeywordOnlyIndex ?? destParamDetails.params.length;
@@ -19125,12 +19252,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 canAssign = false;
             }
         }
-        // If we're checking for full overlapping overloads and the source is
-        // a gradual form, the dest must also be a gradual form.
-        if ((flags & 16 /* AssignTypeFlags.OverloadOverlap */) !== 0 &&
-            types_1.FunctionType.isGradualCallableForm(srcType) &&
-            !types_1.FunctionType.isGradualCallableForm(destType)) {
-            canAssign = false;
+        if ((flags & 16 /* AssignTypeFlags.OverloadOverlap */) !== 0) {
+            // If we're checking for full overlapping overloads and the source is
+            // a gradual form, the dest must also be a gradual form.
+            if (types_1.FunctionType.isGradualCallableForm(srcType) && !types_1.FunctionType.isGradualCallableForm(destType)) {
+                canAssign = false;
+            }
+            // If the src contains a ParamSpec the dest must also.
+            if (srcParamSpec && !destParamSpec) {
+                canAssign = false;
+            }
         }
         // If the source and the dest are using the same ParamSpec, any additional
         // concatenated parameters must match.
@@ -20295,7 +20426,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getTypeClassType,
         getBuiltInObject,
         getTypingType,
-        assignTypeArgs: assignTypeArgs,
+        getTypeCheckerInternalsType,
+        assignTypeArgs,
         reportMissingTypeArgs,
         inferReturnTypeIfNecessary,
         inferVarianceForClass,
@@ -20303,7 +20435,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         isFinalVariableDeclaration,
         isExplicitTypeAliasDeclaration,
         addInformation,
-        addUnusedCode,
         addUnreachableCode,
         addDeprecated,
         addDiagnostic,