@zzzen/pyright-internal 1.2.0-dev.20240218 → 1.2.0-dev.20240225

package/dist/analyzer/typeEvaluator.js

@@ -198,6 +198,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let dictClassType;
     let typedDictClassType;
     let typedDictPrivateClassType;
+    let supportsKeysAndGetItemProtocolType;
     let mappingType;
     let printExpressionSpaceCount = 0;
     let incompleteGenerationCount = 0;
@@ -466,7 +467,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             functionObj = getBuiltInObject(node, 'function');
             unionClassType = getTypesType(node, 'UnionType');
             if (unionClassType && (0, types_1.isClass)(unionClassType)) {
-                unionClassType.details.flags |= 1073741824 /* ClassTypeFlags.SpecialFormClass */;
+                unionClassType.details.flags |= -2147483648 /* ClassTypeFlags.SpecialFormClass */;
             }
             // Initialize and cache "Collection" to break a cyclical dependency
             // that occurs when resolving tuple below.
@@ -483,10 +484,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typedDictClassType = getTypingType(node, 'TypedDict');
             typedDictPrivateClassType = getTypingType(node, '_TypedDict');
             awaitableProtocolType = getTypingType(node, 'Awaitable');
-            mappingType = getTypeshedType(node, 'SupportsKeysAndGetItem');
-            if (!mappingType) {
+            mappingType = getTypingType(node, 'Mapping');
+            supportsKeysAndGetItemProtocolType = getTypeshedType(node, 'SupportsKeysAndGetItem');
+            if (!supportsKeysAndGetItemProtocolType) {
                 // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
-                mappingType = getTypingType(node, 'Mapping');
+                supportsKeysAndGetItemProtocolType = mappingType;
             }
             // Wire up the `Any` class to the special-form version of our internal AnyType.
             const objectClass = getBuiltInType(node, 'object');
@@ -494,7 +496,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 (0, types_1.isInstantiableClass)(objectClass) &&
                 typeClassType &&
                 (0, types_1.isInstantiableClass)(typeClassType)) {
-                const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltInClass */ | 1073741824 /* ClassTypeFlags.SpecialFormClass */, 
+                const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltInClass */ | -2147483648 /* ClassTypeFlags.SpecialFormClass */, 
                 /* typeSourceId */ -1, 
                 /* declaredMetaclass */ undefined, 
                 /* effectiveMetaclass */ typeClassType);
@@ -1582,7 +1584,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // If the function includes a `**kwargs: Unpack[TypedDict]` parameter, the
     // parameter is expanded to include individual keyword args.
     function expandTypedKwargs(functionType) {
-        var _a;
+        var _a, _b;
         const kwargsIndex = functionType.details.parameters.findIndex((param) => param.category === 2 /* ParameterCategory.KwargsDict */);
         if (kwargsIndex < 0) {
             return functionType;
@@ -1592,7 +1594,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!(0, types_1.isClassInstance)(kwargsType) || !types_1.ClassType.isTypedDictClass(kwargsType) || !kwargsType.isUnpacked) {
             return functionType;
         }
-        const tdEntries = (_a = kwargsType.typedDictNarrowedEntries) !== null && _a !== void 0 ? _a : kwargsType.details.typedDictEntries;
+        const tdEntries = (_a = kwargsType.typedDictNarrowedEntries) !== null && _a !== void 0 ? _a : (_b = kwargsType.details.typedDictEntries) === null || _b === void 0 ? void 0 : _b.knownItems;
         if (!tdEntries) {
             return functionType;
         }
@@ -6870,7 +6872,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function evaluateCastCall(argList, errorNode) {
         // Verify that the cast is necessary.
         const castToType = getTypeOfArgumentExpectingType(argList[0], { enforceTypeAnnotationRules: true }).type;
-        const castFromType = getTypeOfArgument(argList[1]).type;
+        let castFromType = getTypeOfArgument(argList[1]).type;
+        if (castFromType.specialForm) {
+            castFromType = castFromType.specialForm;
+        }
         if (types_1.TypeBase.isInstantiable(castToType) && !(0, types_1.isUnknown)(castToType)) {
             if ((0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(castToType), castFromType, {
                 ignorePseudoGeneric: true,
@@ -7345,7 +7350,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // keys are present.
                         const typedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, argType);
                         const diag = new diagnostic_1.DiagnosticAddendum();
-                        typedDictEntries.forEach((entry, name) => {
+                        typedDictEntries.knownItems.forEach((entry, name) => {
                             const paramEntry = paramMap.get(name);
                             if (paramEntry && !paramEntry.isPositionalOnly) {
                                 if (paramEntry.argsReceived > 0) {
@@ -7422,20 +7427,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     else {
                         const strObjType = getBuiltInObject(errorNode, 'str');
-                        if (mappingType &&
-                            (0, types_1.isInstantiableClass)(mappingType) &&
+                        if (supportsKeysAndGetItemProtocolType &&
+                            (0, types_1.isInstantiableClass)(supportsKeysAndGetItemProtocolType) &&
                             strObjType &&
                             (0, types_1.isClassInstance)(strObjType)) {
-                            const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(mappingType));
+                            const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(supportsKeysAndGetItemProtocolType));
                             let isValidMappingType = false;
                             // If this was a TypeVar (e.g. for pseudo-generic classes),
                             // don't emit this error.
                             if ((0, types_1.isTypeVar)(argType)) {
                                 isValidMappingType = true;
                             }
-                            else if (assignType(types_1.ClassType.cloneAsInstance(mappingType), argType, 
+                            else if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemProtocolType), argType, 
                             /* diag */ undefined, mappingTypeVarContext)) {
-                                const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingType, mappingTypeVarContext);
+                                const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(supportsKeysAndGetItemProtocolType, mappingTypeVarContext);
                                 const typeArgs = specializedMapping.typeArguments;
                                 if (typeArgs && typeArgs.length >= 2) {
                                     if (assignType(strObjType, typeArgs[0])) {
@@ -7645,6 +7650,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         argumentCategory: 0 /* ArgumentCategory.Simple */,
                                         typeResult: { type: defaultArgType },
                                     },
+                                    isDefaultArg: true,
                                     errorNode,
                                     paramName: param.name,
                                     isParamNameSynthesized: param.isNameSynthesized,
@@ -8076,15 +8082,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
             specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpackedTuple */ false);
         }
-        // Handle 'TypeGuard' specially. We'll transform the return type into a 'bool'
-        // object with a type argument that reflects the narrowed type.
+        // Handle 'TypeGuard' and 'TypeIs' specially. We'll transform the return type
+        // into a 'bool' object with a type argument that reflects the narrowed type.
         if ((0, types_1.isClassInstance)(specializedReturnType) &&
-            types_1.ClassType.isBuiltIn(specializedReturnType, 'TypeGuard') &&
+            types_1.ClassType.isBuiltIn(specializedReturnType, ['TypeGuard', 'TypeIs']) &&
             specializedReturnType.typeArguments &&
-            specializedReturnType.typeArguments.length > 0 &&
-            (0, types_1.isClassInstance)(returnType) &&
-            returnType.typeArguments &&
-            returnType.typeArguments.length > 0) {
+            specializedReturnType.typeArguments.length > 0) {
             if (boolClassType && (0, types_1.isInstantiableClass)(boolClassType)) {
                 let typeGuardType = specializedReturnType.typeArguments[0];
                 // If the first argument is a simple (non-constrained) TypeVar,
@@ -8099,21 +8102,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         ]);
                     }
                 }
-                let useStrictTypeGuardSemantics = false;
-                if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
-                    // Determine the type of the first parameter.
-                    const paramIndex = type.boundToType ? 1 : 0;
-                    if (paramIndex < type.details.parameters.length) {
-                        const paramType = types_1.FunctionType.getEffectiveParameterType(type, paramIndex);
-                        // If the type guard meets the requirements that the first parameter
-                        // type is a proper subtype of the return type, we can use strict
-                        // type guard semantics.
-                        if (assignType(paramType, returnType.typeArguments[0])) {
-                            useStrictTypeGuardSemantics = true;
-                        }
-                    }
-                }
-                specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, useStrictTypeGuardSemantics));
+                const useTypeIsSemantics = types_1.ClassType.isBuiltIn(specializedReturnType, 'TypeIs');
+                specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, useTypeIsSemantics));
             }
         }
         specializedReturnType = adjustCallableReturnType(specializedReturnType, signatureTracker.getTrackedSignatures());
@@ -8391,6 +8381,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isTypeIncomplete = true;
                 }
             }
+            // If the argument came from a parameter's default argument value,
+            // we may need to specialize the type.
+            if (argParam.isDefaultArg) {
+                argType = (0, typeUtils_1.applySolvedTypeVars)(argType, typeVarContext);
+            }
         }
         // If we're assigning to a var arg dictionary with a TypeVar type,
         // strip literals before performing the assignment. This is used in
@@ -8997,7 +8992,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeLiteral(), argList[1].node || errorNode);
         }
         let classFlags = baseClass.details.flags & ~(1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */);
-        classFlags |= 4096 /* ClassTypeFlags.Final */ | 268435456 /* ClassTypeFlags.NewTypeClass */ | 536870912 /* ClassTypeFlags.ValidTypeAliasClass */;
+        classFlags |= 8192 /* ClassTypeFlags.Final */ | 536870912 /* ClassTypeFlags.NewTypeClass */ | 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */;
         const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
         classType.details.baseClasses.push(isBaseClassAny ? types_1.AnyType.create() : baseClass);
@@ -9046,7 +9041,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!(0, types_1.isClassInstance)(arg1Type) || !(0, typeUtils_1.isTupleClass)(arg1Type) || arg1Type.tupleTypeArguments === undefined) {
             return undefined;
         }
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 536870912 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, arg1Type.details.effectiveMetaclass);
         arg1Type.tupleTypeArguments.forEach((typeArg) => {
             const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
@@ -9356,8 +9351,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (0, types_1.isClassInstance)(keyType) &&
                     types_1.ClassType.isBuiltIn(keyType, 'str') &&
                     (0, typeUtils_1.isLiteralType)(keyType) &&
-                    expectedTypedDictEntries.has(keyType.literalValue)) {
-                    const effectiveValueType = expectedTypedDictEntries.get(keyType.literalValue).valueType;
+                    expectedTypedDictEntries.knownItems.has(keyType.literalValue)) {
+                    const effectiveValueType = expectedTypedDictEntries.knownItems.get(keyType.literalValue).valueType;
                     entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
                     /* flags */ undefined, entryInferenceContext);
@@ -9390,8 +9385,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (entryNode.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */) {
                 let expectedType;
                 if (expectedKeyType && expectedValueType) {
-                    if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
-                        expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(mappingType, [expectedKeyType, expectedValueType], 
+                    if (supportsKeysAndGetItemProtocolType && (0, types_1.isInstantiableClass)(supportsKeysAndGetItemProtocolType)) {
+                        expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(supportsKeysAndGetItemProtocolType, [expectedKeyType, expectedValueType], 
                         /* isTypeArgumentExplicit */ true));
                     }
                 }
@@ -9417,7 +9412,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const strObject = types_1.ClassType.cloneAsInstance(strClassType);
                         const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, unexpandedType, 
                         /* allowNarrowed */ true);
-                        tdEntries.forEach((entry, name) => {
+                        tdEntries.knownItems.forEach((entry, name) => {
                             if (entry.isRequired || entry.isProvided) {
                                 keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneWithLiteral(strObject, name) });
                                 valueTypes.push({ node: entryNode, type: entry.valueType });
@@ -9426,13 +9421,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addUnknown = false;
                     }
                 }
-                else if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
-                    const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(mappingType));
-                    mappingType = (0, typeUtils_1.selfSpecializeClass)(mappingType);
-                    if (assignType(types_1.ClassType.cloneAsInstance(mappingType), unexpandedType, 
+                else if (supportsKeysAndGetItemProtocolType &&
+                    (0, types_1.isInstantiableClass)(supportsKeysAndGetItemProtocolType)) {
+                    const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(supportsKeysAndGetItemProtocolType));
+                    supportsKeysAndGetItemProtocolType = (0, typeUtils_1.selfSpecializeClass)(supportsKeysAndGetItemProtocolType);
+                    if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemProtocolType), unexpandedType, 
                     /* diag */ undefined, mappingTypeVarContext, 
                     /* srcTypeVarContext */ undefined, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
-                        const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingType, mappingTypeVarContext);
+                        const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(supportsKeysAndGetItemProtocolType, mappingTypeVarContext);
                         const typeArgs = specializedMapping.typeArguments;
                         if (typeArgs && typeArgs.length >= 2) {
                             if (forceStrictInference || index < maxEntriesToUseForInference) {
@@ -9907,7 +9903,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }, {
-            dependentType: expectedType,
+            dependentType: inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType,
             allowDiagnostics: !forceSpeculative && !isDiagnosticSuppressedForNode(node) && !(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete),
         });
         // Mark the function type as no longer being evaluated.
@@ -10405,7 +10401,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return type;
     }
-    // Creates a "TypeGuard" type. This is an alias for 'bool', which
+    // Creates a "TypeGuard" and "TypeIs" type. This is an alias for 'bool', which
     // isn't a generic type and therefore doesn't have a typeParameter.
     // We'll abuse our internal types a bit by specializing it with
     // a type argument anyway.
@@ -10923,12 +10919,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined);
         if (aliasMapEntry.isSpecialForm) {
-            specialClassType.details.flags |= 1073741824 /* ClassTypeFlags.SpecialFormClass */;
+            specialClassType.details.flags |= -2147483648 /* ClassTypeFlags.SpecialFormClass */;
         }
         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) {
-            specialClassType.details.flags |= 65536 /* ClassTypeFlags.TypingExtensionClass */;
+            specialClassType.details.flags |= 131072 /* ClassTypeFlags.TypingExtensionClass */;
         }
         const baseClassName = aliasMapEntry.alias || 'object';
         let baseClass;
@@ -10948,7 +10944,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // cause the TypedDict to be marked as abstract.
                 if ((0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, '_TypedDict')) {
                     baseClass = types_1.ClassType.cloneWithNewFlags(baseClass, baseClass.details.flags &
-                        ~(1024 /* ClassTypeFlags.SupportsAbstractMethods */ | 134217728 /* ClassTypeFlags.TypeCheckOnly */));
+                        ~(2048 /* ClassTypeFlags.SupportsAbstractMethods */ | 268435456 /* ClassTypeFlags.TypeCheckOnly */));
                 }
             }
         }
@@ -11004,6 +11000,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 }],
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
@@ -11332,17 +11329,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             fileInfo.isTypeshedStubFile) {
             classFlags |= 1 /* ClassTypeFlags.BuiltInClass */;
             if (fileInfo.isTypingExtensionsStubFile) {
-                classFlags |= 65536 /* ClassTypeFlags.TypingExtensionClass */;
+                classFlags |= 131072 /* ClassTypeFlags.TypingExtensionClass */;
             }
             if (node.name.value === 'property') {
-                classFlags |= 2048 /* ClassTypeFlags.PropertyClass */;
+                classFlags |= 4096 /* ClassTypeFlags.PropertyClass */;
             }
             if (node.name.value === 'tuple') {
-                classFlags |= 524288 /* ClassTypeFlags.TupleClass */;
+                classFlags |= 1048576 /* ClassTypeFlags.TupleClass */;
             }
         }
         if (fileInfo.isStubFile) {
-            classFlags |= 8388608 /* ClassTypeFlags.DefinedInStub */;
+            classFlags |= 16777216 /* ClassTypeFlags.DefinedInStub */;
         }
         const classType = types_1.ClassType.createInstantiable(node.name.value, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, node.name.value), fileInfo.moduleName, fileInfo.fileUri, classFlags, 
         /* typeSourceId */ 0, 
@@ -11365,7 +11362,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (classDecl && classSymbol) {
             setSymbolResolutionPartialType(classSymbol, classDecl, classType);
         }
-        classType.details.flags |= 131072 /* ClassTypeFlags.PartiallyEvaluated */;
+        classType.details.flags |= 262144 /* ClassTypeFlags.PartiallyEvaluated */;
         classType.details.declaration = classDecl;
         try {
             writeTypeCache(node, { type: classType }, /* flags */ undefined);
@@ -11450,10 +11447,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_7) {
                                     addError(localize_1.LocMessage.protocolIllegal(), arg.valueExpression);
                                 }
-                                classType.details.flags |= 8192 /* ClassTypeFlags.ProtocolClass */;
+                                classType.details.flags |= 16384 /* ClassTypeFlags.ProtocolClass */;
                             }
                             if (types_1.ClassType.isBuiltIn(argType, 'property')) {
-                                classType.details.flags |= 2048 /* ClassTypeFlags.PropertyClass */;
+                                classType.details.flags |= 4096 /* ClassTypeFlags.PropertyClass */;
                             }
                             // If the class directly derives from NamedTuple (in Python 3.6 or
                             // newer), it's considered a (read-only) dataclass.
@@ -11462,13 +11459,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     classType.details.flags |=
                                         4 /* ClassTypeFlags.DataClass */ |
                                             32 /* ClassTypeFlags.SkipSynthesizedDataClassEq */ |
-                                            16777216 /* ClassTypeFlags.ReadOnlyInstanceVariables */;
+                                            33554432 /* ClassTypeFlags.ReadOnlyInstanceVariables */;
                                 }
                             }
                             // If the class directly derives from TypedDict or from a class that is
                             // a TypedDict, it is considered a TypedDict.
                             if (types_1.ClassType.isBuiltIn(argType, 'TypedDict') || types_1.ClassType.isTypedDictClass(argType)) {
                                 classType.details.flags |= 128 /* ClassTypeFlags.TypedDictClass */;
+                                // Propagate the "effectively closed" flag from base classes.
+                                if (types_1.ClassType.isTypedDictEffectivelyClosed(argType)) {
+                                    classType.details.flags |= 512 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                                }
                             }
                             // Validate that the class isn't deriving from itself, creating a
                             // circular dependency.
@@ -11498,7 +11499,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     classType.details.baseClasses.push(argType);
                     if ((0, types_1.isInstantiableClass)(argType)) {
                         if (types_1.ClassType.isEnumClass(argType)) {
-                            classType.details.flags |= 1048576 /* ClassTypeFlags.EnumClass */;
+                            classType.details.flags |= 2097152 /* ClassTypeFlags.EnumClass */;
                         }
                         // Determine if the class is abstract. Protocol classes support abstract methods
                         // because they are constructed by the _ProtocolMeta metaclass, which derives
@@ -11507,10 +11508,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // 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))) {
-                            classType.details.flags |= 1024 /* ClassTypeFlags.SupportsAbstractMethods */;
+                            classType.details.flags |= 2048 /* ClassTypeFlags.SupportsAbstractMethods */;
                         }
                         if (types_1.ClassType.isPropertyClass(argType)) {
-                            classType.details.flags |= 2048 /* ClassTypeFlags.PropertyClass */;
+                            classType.details.flags |= 4096 /* ClassTypeFlags.PropertyClass */;
                         }
                         if (types_1.ClassType.isFinal(argType)) {
                             const className = printObjectTypeForClass(argType);
@@ -11552,7 +11553,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else if (types_1.ClassType.isTypedDictClass(classType)) {
-                    if (arg.name.value === 'total') {
+                    if (arg.name.value === 'total' || arg.name.value === 'closed') {
                         // The "total" and "readonly" parameters apply only for TypedDict classes.
                         // PEP 589 specifies that the parameter must be either True or False.
                         const constArgValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
@@ -11560,7 +11561,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             addError(localize_1.LocMessage.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression);
                         }
                         else if (arg.name.value === 'total' && !constArgValue) {
-                            classType.details.flags |= 256 /* ClassTypeFlags.CanOmitDictValues */;
+                            classType.details.flags |= 1024 /* ClassTypeFlags.CanOmitDictValues */;
+                        }
+                        else if (arg.name.value === 'closed' && constArgValue) {
+                            if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+                                classType.details.flags |=
+                                    256 /* ClassTypeFlags.TypedDictMarkedClosed */ | 512 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                            }
                         }
                     }
                     else {
@@ -11681,7 +11688,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 param.category === 0 /* ParameterCategory.Simple */ &&
                                 !param.defaultValue);
                             if (genericParams.length > 0) {
-                                classType.details.flags |= 16384 /* ClassTypeFlags.PseudoGenericClass */;
+                                classType.details.flags |= 32768 /* ClassTypeFlags.PseudoGenericClass */;
                                 // Create a type parameter for each simple, named parameter
                                 // in the __init__ method.
                                 classType.details.typeParameters = genericParams.map((param) => {
@@ -11702,7 +11709,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (classType.details.typeParameters.length === 0 && !types_1.ClassType.isBuiltIn(classType, 'type')) {
                 if (classType.details.baseClasses.some((baseClass) => (0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.hasCustomClassGetItem(baseClass)) ||
                     classType.details.fields.has('__class_getitem__')) {
-                    classType.details.flags |= 262144 /* ClassTypeFlags.HasCustomClassGetItem */;
+                    classType.details.flags |= 524288 /* ClassTypeFlags.HasCustomClassGetItem */;
                 }
             }
             // Determine the effective metaclass.
@@ -11715,17 +11722,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     classType.details.declaredMetaclass = metaclassType;
                     if ((0, types_1.isInstantiableClass)(metaclassType)) {
                         if ((0, enums_1.isEnumMetaclass)(metaclassType)) {
-                            classType.details.flags |= 1048576 /* ClassTypeFlags.EnumClass */;
+                            classType.details.flags |= 2097152 /* ClassTypeFlags.EnumClass */;
                         }
                         if (types_1.ClassType.isBuiltIn(metaclassType, 'ABCMeta')) {
-                            classType.details.flags |= 1024 /* ClassTypeFlags.SupportsAbstractMethods */;
+                            classType.details.flags |= 2048 /* ClassTypeFlags.SupportsAbstractMethods */;
                         }
                     }
                 }
             }
             const effectiveMetaclass = computeEffectiveMetaclass(classType, node.name);
             // Clear the "partially constructed" flag.
-            classType.details.flags &= ~131072 /* ClassTypeFlags.PartiallyEvaluated */;
+            classType.details.flags &= ~262144 /* ClassTypeFlags.PartiallyEvaluated */;
             // Now determine the decorated type of the class.
             let decoratedType = classType;
             let foundUnknown = false;
@@ -11787,7 +11794,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (foundInvalidBaseClass) {
                     addError(localize_1.LocMessage.typedDictBaseClass() + diag.getString(), node.name);
                 }
-                (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType, (0, types_1.isClass)(decoratedType) && types_1.ClassType.isFinal(decoratedType));
+                (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType);
             }
             // Synthesize dataclass methods.
             if (types_1.ClassType.isDataClass(classType)) {
@@ -12460,8 +12467,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (index >= firstNonClsSelfParamIndex) {
                 let isImplicitPositionOnlyParam = false;
                 if (param.category === 0 /* ParameterCategory.Simple */ && param.name) {
-                    if ((0, symbolNameUtils_1.isPrivateName)(param.name.value)) {
+                    if ((0, symbolNameUtils_1.isPrivateName)(param.name.value) &&
+                        !node.parameters.some((p) => p.category === 0 /* ParameterCategory.Simple */ && !p.name)) {
                         isImplicitPositionOnlyParam = true;
+                        // If the parameter name indicates an implicit position-only parameter
+                        // but we have already seen non-position-only parameters, report an error.
+                        if (!paramsArePositionOnly &&
+                            functionType.details.parameters.every((p) => p.category === 0 /* ParameterCategory.Simple */)) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.positionOnlyAfterNon(), param.name);
+                        }
                     }
                 }
                 else {
@@ -13980,7 +13994,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 case 'Concatenate': {
                     return { type: createConcatenateType(classType, errorNode, typeArgs, flags) };
                 }
-                case 'TypeGuard': {
+                case 'TypeGuard':
+                case 'TypeIs': {
                     return { type: createTypeGuardType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Unpack': {
@@ -14527,7 +14542,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // is a valid entry in the TypedDict to avoid resolving declarations for
                 // synthesized symbols such as 'get'.
                 if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
-                    const entry = (_a = subtype.details.typedDictEntries) === null || _a === void 0 ? void 0 : _a.get(node.value);
+                    const entry = (_a = subtype.details.typedDictEntries) === null || _a === void 0 ? void 0 : _a.knownItems.get(node.value);
                     if (entry) {
                         const symbol = (_b = (0, typeUtils_1.lookUpObjectMember)(subtype, node.value)) === null || _b === void 0 ? void 0 : _b.symbol;
                         if (symbol) {
@@ -14895,7 +14910,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else {
-                const boundType = getTypeOfExpressionExpectingType(node.boundExpression).type;
+                const boundType = getTypeOfExpressionExpectingType(node.boundExpression, {
+                    disallowProtocolAndTypedDict: true,
+                }).type;
                 if ((0, typeUtils_1.requiresSpecialization)(boundType, { ignorePseudoGeneric: true })) {
                     addError(localize_1.LocMessage.typeVarConstraintGeneric(), node.boundExpression);
                 }
@@ -15844,26 +15861,66 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Handle typed dicts. They also use a form of structural typing for type
         // checking, as defined in PEP 589.
-        if (types_1.ClassType.isTypedDictClass(destType) &&
-            types_1.ClassType.isTypedDictClass(srcType) &&
-            !types_1.ClassType.isSameGenericClass(destType, srcType)) {
-            if (!(0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, flags, recursionCount)) {
-                return false;
+        if (types_1.ClassType.isTypedDictClass(srcType)) {
+            if (types_1.ClassType.isTypedDictClass(destType) && !types_1.ClassType.isSameGenericClass(destType, srcType)) {
+                if (!(0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, flags, recursionCount)) {
+                    return false;
+                }
+                if (types_1.ClassType.isFinal(destType) !== types_1.ClassType.isFinal(srcType)) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typedDictFinalMismatch().format({
+                        sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
+                        destType: printType((0, typeUtils_1.convertToInstance)(destType)),
+                    }));
+                    return false;
+                }
+                // If invariance is being enforced, the two TypedDicts must be assignable to each other.
+                if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
+                    return (0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, srcType, destType, 
+                    /* diag */ undefined, 
+                    /* typeVarContext */ undefined, flags, recursionCount);
+                }
+                return true;
             }
-            if (types_1.ClassType.isFinal(destType) !== types_1.ClassType.isFinal(srcType)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typedDictFinalMismatch().format({
-                    sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
-                    destType: printType((0, typeUtils_1.convertToInstance)(destType)),
-                }));
-                return false;
+            // Handle some special cases where a TypedDict can act like
+            // a Mapping[str, T] or a dict[str, T].
+            if (types_1.ClassType.isBuiltIn(destType, 'Mapping')) {
+                const mappingValueType = (0, typedDicts_1.getTypedDictMappingEquivalent)(evaluatorInterface, srcType);
+                if (mappingValueType &&
+                    mappingType &&
+                    (0, types_1.isInstantiableClass)(mappingType) &&
+                    strClassType &&
+                    (0, types_1.isInstantiableClass)(strClassType)) {
+                    srcType = types_1.ClassType.cloneForSpecialization(mappingType, [types_1.ClassType.cloneAsInstance(strClassType), mappingValueType], 
+                    /* isTypeArgumentExplicit */ true);
+                }
             }
-            // If invariance is being enforced, the two TypedDicts must be assignable to each other.
-            if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
-                return (0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, srcType, destType, 
-                /* diag */ undefined, 
-                /* typeVarContext */ undefined, flags, recursionCount);
+            else if (types_1.ClassType.isBuiltIn(destType, ['dict', 'MutableMapping'])) {
+                const dictValueType = (0, typedDicts_1.getTypedDictDictEquivalent)(evaluatorInterface, srcType, recursionCount);
+                if (dictValueType &&
+                    dictClassType &&
+                    (0, types_1.isInstantiableClass)(dictClassType) &&
+                    strClassType &&
+                    (0, types_1.isInstantiableClass)(strClassType)) {
+                    srcType = types_1.ClassType.cloneForSpecialization(dictClassType, [types_1.ClassType.cloneAsInstance(strClassType), dictValueType], 
+                    /* isTypeArgumentExplicit */ true);
+                }
+            }
+        }
+        // See if the dest type is a TypedDict class and the source is a compatible dict.
+        if (types_1.ClassType.isTypedDictClass(destType) && types_1.ClassType.isBuiltIn(srcType, 'dict')) {
+            if (srcType.typeArguments &&
+                srcType.typeArguments.length === 2 &&
+                (0, types_1.isClassInstance)(srcType.typeArguments[0]) &&
+                types_1.ClassType.isBuiltIn(srcType.typeArguments[0], 'str')) {
+                const dictValueType = (0, typedDicts_1.getTypedDictDictEquivalent)(evaluatorInterface, destType, recursionCount);
+                if (dictValueType &&
+                    assignType(dictValueType, srcType.typeArguments[1], 
+                    /* diag */ undefined, 
+                    /* destTypeVarContext */ undefined, 
+                    /* srcTypeVarContext */ undefined, 1 /* AssignTypeFlags.EnforceInvariance */, recursionCount + 1)) {
+                    return true;
+                }
             }
-            return true;
         }
         // Handle special-case type promotions.
         if (destType.includePromotions) {
@@ -16635,7 +16692,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, types_1.isNever)(srcType)) {
             if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
-                return (0, types_1.isNever)(destType);
+                if ((0, types_1.isNever)(destType)) {
+                    return true;
+                }
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+                return false;
             }
             const targetTypeVarContext = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destTypeVarContext : srcTypeVarContext;
             if (targetTypeVarContext) {
@@ -16768,7 +16829,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return !isLiteral;
                 }
             }
-            else if (types_1.ClassType.isBuiltIn(destType, 'TypeGuard')) {
+            else if (types_1.ClassType.isBuiltIn(destType, ['TypeGuard', 'TypeIs'])) {
                 // All the source to be a "bool".
                 if ((originalFlags & 128 /* AssignTypeFlags.AllowBoolTypeGuard */) !== 0) {
                     if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'bool')) {
@@ -17946,10 +18007,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isReturnTypeCompatible = true;
                 }
                 else {
-                    // Handle the special case where the return type is a TypeGuard[T].
-                    // This should also act as a bool, since that's its type at runtime.
+                    // Handle the special case where the return type is a TypeGuard[T]
+                    // or TypeIs[T]. This should also act as a bool, since that's its
+                    // type at runtime.
                     if ((0, types_1.isClassInstance)(srcReturnType) &&
-                        types_1.ClassType.isBuiltIn(srcReturnType, 'TypeGuard') &&
+                        types_1.ClassType.isBuiltIn(srcReturnType, ['TypeGuard', 'TypeIs']) &&
                         boolClassType &&
                         (0, types_1.isInstantiableClass)(boolClassType)) {
                         if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(boolClassType), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {