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

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);
@@ -803,6 +805,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const exprTypeResult = getTypeOfExpression(node.expression, flags, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
         const typeResult = {
             type: getTypeOfAwaitable(exprTypeResult.type, node.expression),
+            isIncomplete: exprTypeResult.isIncomplete,
+            typeErrors: exprTypeResult.typeErrors,
         };
         if (exprTypeResult.isIncomplete) {
             typeResult.isIncomplete = true;
@@ -1547,7 +1551,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // see if we can find a better signature from the `__new__` method.
                         if (!constructorType || isObjectInit || isDefaultParams) {
                             const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluatorInterface, callNode, subtype, 0 /* MemberAccessFlags.Default */);
-                            if (newMethodResult && !newMethodResult.typeErrors && (0, types_1.isFunction)(newMethodResult.type)) {
+                            if (newMethodResult && !newMethodResult.typeErrors) {
                                 if ((0, types_1.isFunction)(newMethodResult.type) &&
                                     newMethodResult.type.details.fullName !== 'builtins.object.__new__') {
                                     constructorType = newMethodResult.type;
@@ -1582,7 +1586,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 +1596,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;
         }
@@ -2034,10 +2038,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (checkCodeFlowTooComplex(node)) {
             return true;
         }
-        const codeFlowResult = analyzer.getTypeFromCodeFlow(flowNode, 
-        /* reference */ undefined, 
-        /* targetSymbolId */ undefined, 
-        /* typeAtStart */ types_1.UnboundType.create());
+        const codeFlowResult = analyzer.getTypeFromCodeFlow(flowNode, /* reference */ undefined, {
+            typeAtStart: types_1.UnboundType.create(),
+        });
         return codeFlowResult.type !== undefined && !(0, types_1.isNever)(codeFlowResult.type);
     }
     // Determines whether there is a code flow path from sourceNode to sinkNode.
@@ -2192,8 +2195,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiagAddendum) {
                     diagAddendum = expectedTypeDiagAddendum;
                 }
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatch().format(printSrcDestTypes(type, declaredType)) +
-                    diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_c = (_b = diagAddendum.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : srcExpression) !== null && _c !== void 0 ? _c : nameNode);
+                if (!isTypeIncomplete) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatch().format(printSrcDestTypes(type, declaredType)) +
+                        diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_c = (_b = diagAddendum.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : srcExpression) !== null && _c !== void 0 ? _c : nameNode);
+                }
                 // Replace the assigned type with the (unnarrowed) declared type.
                 destType = declaredType;
             }
@@ -2977,8 +2982,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                         }
                     }
-                    const codeFlowTypeResult = getFlowTypeOfReference(node, symbol.id, typeAtStart, 
-                    /* startNode */ undefined, {
+                    const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
+                        targetSymbolId: symbol.id,
+                        typeAtStart,
                         skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
                     });
                     if (codeFlowTypeResult.type) {
@@ -3131,7 +3137,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (symbolWithScope.symbol.isInitiallyUnbound()) {
                             typeAtStart = types_1.UnboundType.create();
                         }
-                        return getFlowTypeOfReference(node, symbolWithScope.symbol.id, typeAtStart, innerScopeNode);
+                        return getFlowTypeOfReference(node, innerScopeNode, {
+                            targetSymbolId: symbolWithScope.symbol.id,
+                            typeAtStart,
+                        });
                     }
                 }
             }
@@ -3455,8 +3464,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             // See if we can refine the type based on code flow analysis.
-            const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, typeAtStart, 
-            /* startNode */ undefined, {
+            const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
+                targetSymbolId: symbol_1.indeterminateSymbolId,
+                typeAtStart,
                 isTypeAtStartIncomplete,
                 skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
             });
@@ -4383,10 +4393,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             if (baseTypeSupportsIndexNarrowing) {
                 // Before performing code flow analysis, update the cache to prevent recursion.
-                writeTypeCache(node, indexTypeResult, flags);
+                writeTypeCache(node, { ...indexTypeResult, isIncomplete: true }, flags);
                 // See if we can refine the type based on code flow analysis.
-                const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, indexTypeResult.type, 
-                /* startNode */ undefined, {
+                const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
+                    targetSymbolId: symbol_1.indeterminateSymbolId,
+                    typeAtStart: indexTypeResult.type,
                     isTypeAtStartIncomplete: !!baseTypeResult.isIncomplete || !!indexTypeResult.isIncomplete,
                     skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
                 });
@@ -4748,8 +4759,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return createLiteralType(concreteSubtype, node, flags);
                 }
                 if (types_1.ClassType.isBuiltIn(concreteSubtype, 'InitVar')) {
-                    // Special-case InitVar, used in data classes.
+                    // Special-case InitVar, used in dataclasses.
                     const typeArgs = getTypeArgs(node, flags);
+                    if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+                        if ((flags & 32768 /* EvaluatorFlags.VariableTypeAnnotation */) === 0) {
+                            addError(localize_1.LocMessage.initVarNotAllowed(), node.baseExpression);
+                        }
+                    }
                     if (typeArgs.length === 1) {
                         return typeArgs[0].type;
                     }
@@ -6870,7 +6886,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 +7364,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 +7441,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 +7664,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         argumentCategory: 0 /* ArgumentCategory.Simple */,
                                         typeResult: { type: defaultArgType },
                                     },
+                                    isDefaultArg: true,
                                     errorNode,
                                     paramName: param.name,
                                     isParamNameSynthesized: param.isNameSynthesized,
@@ -8076,15 +8096,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 +8116,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 +8395,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
@@ -8986,6 +8995,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeAnyOrUnknown(), (_c = argList[1].node) !== null && _c !== void 0 ? _c : errorNode);
             isBaseClassAny = true;
         }
+        // Specifically disallow Annotated.
+        if (baseClass.specialForm &&
+            (0, types_1.isInstantiableClass)(baseClass.specialForm) &&
+            types_1.ClassType.isBuiltIn(baseClass.specialForm, 'Annotated')) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeNotAClass(), argList[1].node || errorNode);
+            return undefined;
+        }
         if (!(0, types_1.isInstantiableClass)(baseClass)) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeNotAClass(), argList[1].node || errorNode);
             return undefined;
@@ -8997,7 +9013,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 +9062,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 +9372,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 +9406,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 +9433,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 +9442,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 +9924,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 +10422,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 +10940,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 +10965,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 +11021,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 +11350,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 +11383,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 +11468,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 +11480,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 +11520,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 +11529,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 +11574,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 +11582,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 +11709,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 +11730,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 +11743,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 +11815,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 +12488,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 {
@@ -13858,7 +13893,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // flow analysis starts from the reference node, but startNode can be
     // specified to override this in a few special cases (functions and
     // lambdas) to support analysis of captured variables.
-    function getFlowTypeOfReference(reference, targetSymbolId, typeAtStart, startNode, options) {
+    function getFlowTypeOfReference(reference, startNode, options) {
         var _a;
         // See if this execution scope requires code flow for this reference expression.
         const referenceKey = (0, codeFlowTypes_1.createKeyForReference)(reference);
@@ -13887,7 +13922,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (flowNode === undefined) {
             return { type: undefined, isIncomplete: false };
         }
-        return analyzer.getTypeFromCodeFlow(flowNode, reference, targetSymbolId, typeAtStart, options);
+        return analyzer.getTypeFromCodeFlow(flowNode, reference, options);
     }
     // Specializes the specified (potentially generic) class type using
     // the specified type arguments, reporting errors as appropriate.
@@ -13980,7 +14015,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': {
@@ -13991,10 +14027,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
                 }
                 case 'ReadOnly': {
-                    if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
-                        return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
-                    }
-                    break;
+                    return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
                 }
                 case 'Self': {
                     return { type: createSelfType(classType, errorNode, typeArgs, flags) };
@@ -14527,7 +14560,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 +14928,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);
                 }
@@ -15544,7 +15579,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // into account argument types to infer the return type.
     function getFunctionEffectiveReturnType(type, args, inferTypeIfNeeded = true) {
         const specializedReturnType = types_1.FunctionType.getSpecializedReturnType(type, /* includeInferred */ false);
-        if (specializedReturnType) {
+        if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
             return adjustCallableReturnType(specializedReturnType, /* trackedSignatures */ undefined);
         }
         if (inferTypeIfNeeded) {
@@ -15844,26 +15879,50 @@ 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);
+                }
             }
-            return true;
         }
         // Handle special-case type promotions.
         if (destType.includePromotions) {
@@ -16111,15 +16170,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isVariadicTypeVar)(destTypeArgs[destUnboundedOrVariadicIndex].type)) {
                     if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                         const removedArgs = srcTypeArgs.splice(destUnboundedOrVariadicIndex, srcArgsToCapture);
-                        // Package up the remaining type arguments into a tuple object.
-                        const variadicTuple = makeTupleObject(removedArgs.map((typeArg) => {
-                            return {
-                                type: typeArg.type,
-                                isUnbounded: typeArg.isUnbounded,
-                                isOptional: typeArg.isOptional,
-                            };
-                        }), 
-                        /* isUnpackedTuple */ true);
+                        let variadicTuple;
+                        // If we're left with a single unpacked variadic type var, there's no
+                        // need to wrap it in a nested tuple.
+                        if (removedArgs.length === 1 && (0, types_1.isUnpackedVariadicTypeVar)(removedArgs[0].type)) {
+                            variadicTuple = removedArgs[0].type;
+                        }
+                        else {
+                            // Package up the remaining type arguments into a tuple object.
+                            variadicTuple = makeTupleObject(removedArgs.map((typeArg) => {
+                                return {
+                                    type: typeArg.type,
+                                    isUnbounded: typeArg.isUnbounded,
+                                    isOptional: typeArg.isOptional,
+                                };
+                            }), 
+                            /* isUnpackedTuple */ true);
+                        }
                         srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
                             type: variadicTuple,
                             isUnbounded: false,
@@ -16635,7 +16702,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 +16839,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')) {
@@ -17335,6 +17406,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isTypeSame)(destType, srcSubtype, { ignorePseudoGeneric: true }, recursionCount)) {
                 return false;
             }
+            if ((0, typeUtils_1.isIncompleteUnknown)(srcSubtype)) {
+                return false;
+            }
             const destTypeVarName = types_1.TypeVarType.getNameWithScope(destType);
             // Determine which conditions on this type apply to this type variable.
             // There might be more than one of them.
@@ -17946,10 +18020,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)) {
@@ -18311,9 +18386,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     !(0, symbolNameUtils_1.isPrivateOrProtectedName)(baseParam.name || '') &&
                     baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly &&
                     baseParam.category === 0 /* ParameterCategory.Simple */ &&
+                    enforceParamNames &&
                     baseParam.name !== overrideParam.name) {
                     if (overrideParam.category === 0 /* ParameterCategory.Simple */) {
-                        if (enforceParamNames && !baseParam.isNameSynthesized) {
+                        if (!baseParam.isNameSynthesized) {
                             if (overrideParamDetails.params[i].source === parameterUtils_1.ParameterSource.PositionOnly) {
                                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
                                     index: i + 1,