@zzzen/pyright-internal 1.2.0-dev.20231231 → 1.2.0-dev.20240114

package/dist/analyzer/typeEvaluator.js

@@ -187,6 +187,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let noneType;
     let objectType;
     let typeClassType;
+    let unionClassType;
     let awaitableProtocolType;
     let functionObj;
     let tupleClassType;
@@ -462,6 +463,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             objectType = getBuiltInObject(node, 'object');
             typeClassType = getBuiltInType(node, 'type');
             functionObj = getBuiltInObject(node, 'function');
+            unionClassType = getTypesType(node, 'UnionType');
+            if (unionClassType && (0, types_1.isClass)(unionClassType)) {
+                unionClassType.details.flags |= 1073741824 /* ClassTypeFlags.SpecialFormClass */;
+            }
             // Initialize and cache "Collection" to break a cyclical dependency
             // that occurs when resolving tuple below.
             getTypingType(node, 'Collection');
@@ -482,6 +487,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
                 mappingType = getTypingType(node, 'Mapping');
             }
+            // Wire up the `Any` class to the special-form version of our internal AnyType.
+            const objectClass = getBuiltInType(node, 'object');
+            if (objectClass &&
+                (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 */, 
+                /* typeSourceId */ -1, 
+                /* declaredMetaclass */ undefined, 
+                /* effectiveMetaclass */ typeClassType);
+                anyClass.details.baseClasses.push(objectClass);
+                (0, typeUtils_1.computeMroLinearization)(anyClass);
+                const anySpecialForm = types_1.AnyType.createSpecialForm();
+                if ((0, types_1.isAny)(anySpecialForm)) {
+                    anySpecialForm.specialForm = anyClass;
+                }
+            }
         }
     }
     function getTypeOfExpression(node, flags = 0 /* EvaluatorFlags.None */, inferenceContext) {
@@ -755,7 +777,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) &&
                 types_1.ClassType.isTupleClass(typeResult.type) &&
                 ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
-            const isEllipsis = (0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ellipsis');
+            const isEllipsis = (0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, ['EllipsisType', 'ellipsis']);
             if (!isEmptyVariadic && !isEllipsis) {
                 addExpectedClassDiagnostic(typeResult.type, node);
                 typeResult.type = types_1.UnknownType.create();
@@ -783,11 +805,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeResult;
     }
     function getTypeOfEllipsis(flags, typeResult, node) {
+        var _a, _b;
         if ((flags & 1 /* EvaluatorFlags.ConvertEllipsisToAny */) !== 0) {
             typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true) };
         }
         else {
-            const ellipsisType = getBuiltInObject(node, 'ellipsis') || types_1.AnyType.create();
+            const ellipsisType = (_b = (_a = getBuiltInObject(node, 'EllipsisType')) !== null && _a !== void 0 ? _a : getBuiltInObject(node, 'ellipsis')) !== null && _b !== void 0 ? _b : types_1.AnyType.create();
             typeResult = { type: ellipsisType };
         }
         return typeResult;
@@ -1637,7 +1660,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return getDeclaredTypeForExpression(expression.valueExpression, usage);
             }
             case 35 /* ParseNodeType.MemberAccess */: {
-                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 16777218 /* EvaluatorFlags.MemberAccessBaseDefaults */).type);
+                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */).type);
                 let classMemberInfo;
                 if ((0, types_1.isClassInstance)(baseType)) {
                     classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseType, expression.memberName.value, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
@@ -1924,10 +1947,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getNoneType() {
         return noneType !== null && noneType !== void 0 ? noneType : types_1.UnknownType.create();
     }
+    function getUnionClassType() {
+        return unionClassType !== null && unionClassType !== void 0 ? unionClassType : types_1.UnknownType.create();
+    }
     function getTypingType(node, symbolName) {
         var _a;
         return ((_a = getTypeOfModule(node, symbolName, ['typing'])) !== null && _a !== void 0 ? _a : getTypeOfModule(node, symbolName, ['typing_extensions']));
     }
+    function getTypesType(node, symbolName) {
+        return getTypeOfModule(node, symbolName, ['types']);
+    }
     function getTypeshedType(node, symbolName) {
         return getTypeOfModule(node, symbolName, ['_typeshed']);
     }
@@ -2193,7 +2222,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(nameNode, { type: destType, isIncomplete: isTypeIncomplete }, 0 /* EvaluatorFlags.None */);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
-        const baseTypeResult = getTypeOfExpression(target.leftExpression, 16777218 /* EvaluatorFlags.MemberAccessBaseDefaults */);
+        const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */);
         const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
         // Handle member accesses (e.g. self.x or cls.y).
         if (target.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
@@ -2653,7 +2682,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Is the source expression a TypeVar() call?
         if ((0, types_1.isTypeVar)(type)) {
             if (srcExpr && srcExpr.nodeType === 9 /* ParseNodeType.Call */) {
-                const callType = getTypeOfExpression(srcExpr.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */).type;
+                const callType = getTypeOfExpression(srcExpr.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
                 if ((0, types_1.isInstantiableClass)(callType) &&
                     (types_1.ClassType.isBuiltIn(callType, 'TypeVar') ||
                         types_1.ClassType.isBuiltIn(callType, 'TypeVarTuple') ||
@@ -2812,7 +2841,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 35 /* ParseNodeType.MemberAccess */: {
-                const baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* EvaluatorFlags.MemberAccessBaseDefaults */);
+                const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */);
                 const delAccessResult = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* EvaluatorFlags.None */);
                 const resultToCache = {
                     type: delAccessResult.type,
@@ -2857,7 +2886,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfName(node, flags) {
-        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
         let symbol;
@@ -3012,17 +3040,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) === 0) {
             reportUseOfTypeCheckOnly(type, node);
         }
-        if ((flags & 16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */) !== 0) {
-            if (((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.name) && type.typeAliasInfo.isPep695Syntax && types_1.TypeBase.isSpecialForm(type)) {
-                const typeAliasType = getTypingType(node, 'TypeAliasType');
-                if (typeAliasType && (0, types_1.isInstantiableClass)(typeAliasType)) {
-                    type = types_1.ClassType.cloneAsInstance(typeAliasType);
-                }
-                else {
-                    type = types_1.UnknownType.create();
-                }
-            }
-        }
         if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0) {
             if ((flags & 1024 /* EvaluatorFlags.AllowGenericClassType */) === 0) {
                 if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'Generic')) {
@@ -3269,6 +3286,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (param.details.defaultType || param.details.isParamSpec) {
                     defaultType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
                 }
+                else if (param.details.isVariadic && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                    defaultType = types_1.ClassType.cloneForUnpacked((0, typeUtils_1.specializeTupleClass)(types_1.ClassType.cloneAsInstance(tupleClassType), [
+                        { type: types_1.UnknownType.create(), isUnbounded: true },
+                    ]));
+                }
                 else {
                     defaultType = types_1.UnknownType.create();
                 }
@@ -3390,7 +3412,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfMemberAccess(node, flags) {
         var _a;
         // Compute flags specifically for evaluating the left expression.
-        let leftExprFlags = 16777218 /* EvaluatorFlags.MemberAccessBaseDefaults */;
+        let leftExprFlags = 2 /* EvaluatorFlags.MemberAccessBaseDefaults */;
         leftExprFlags |=
             flags &
                 (256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
@@ -3461,8 +3483,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // cases where a type is passed as an argument (e.g. "defaultdict(list)").
         // It can also come up in cases like "isinstance(x, (list, dict))".
         // We need to check for functions as well to handle Callable.
-        if ((0, types_1.isInstantiableClass)(typeResult.type) ||
-            ((0, types_1.isFunction)(typeResult.type) && types_1.TypeBase.isSpecialForm(typeResult.type))) {
+        if (((0, types_1.isInstantiableClass)(typeResult.type) && !typeResult.type.includeSubclasses) ||
+            typeResult.type.specialForm) {
             const argNode = ParseTreeUtils.getParentNodeOfType(node, 1 /* ParseNodeType.Argument */);
             if (argNode && ((_a = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */) {
                 skipPartialUnknownCheck = true;
@@ -3493,12 +3515,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseType)) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
-        // Handle the special case where the expression is an actual
-        // UnionType special form.
-        if ((0, types_1.isUnion)(baseType) && types_1.TypeBase.isSpecialForm(baseType)) {
-            if (objectType) {
-                baseType = objectType;
-            }
+        if (baseType.specialForm) {
+            baseType = baseType.specialForm;
         }
         if ((0, types_1.isParamSpec)(baseType) && baseType.paramSpecAccess) {
             baseType = makeTopLevelTypeVarsConcrete(baseType);
@@ -4348,7 +4366,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        const indexTypeResult = getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'get' }, flags & ~16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */);
+        const indexTypeResult = getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'get' }, flags);
         if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(node)) {
             // We limit type narrowing for index expressions to built-in types that are
             // known to have symmetric __getitem__ and __setitem__ methods (i.e. the value
@@ -4383,10 +4401,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return indexTypeResult;
     }
+    // If the list of type parameters includes a TypeVarTuple, we may need to adjust
+    // the supplied type arguments to map to the type parameter list.
     function adjustTypeArgumentsForVariadicTypeVar(typeArgs, typeParameters, errorNode) {
         const variadicIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
+        // Is there a *tuple[T, ...] somewhere in the type arguments that we can expand if needed?
+        let srcUnboundedTupleType;
+        let srcUnboundedTupleIndex = typeArgs.findIndex((arg) => {
+            if ((0, types_1.isUnpackedClass)(arg.type) &&
+                arg.type.tupleTypeArguments &&
+                arg.type.tupleTypeArguments.length === 1 &&
+                arg.type.tupleTypeArguments[0].isUnbounded) {
+                srcUnboundedTupleType = arg.type.tupleTypeArguments[0].type;
+                return true;
+            }
+            return false;
+        });
+        if (srcUnboundedTupleType &&
+            srcUnboundedTupleIndex >= 0 &&
+            variadicIndex >= 0 &&
+            typeArgs.length < typeParameters.length) {
+            // "Smear" the tuple type across type argument slots prior to the variadic type var.
+            while (variadicIndex > srcUnboundedTupleIndex) {
+                typeArgs = [
+                    ...typeArgs.slice(0, srcUnboundedTupleIndex),
+                    { node: typeArgs[srcUnboundedTupleIndex].node, type: srcUnboundedTupleType },
+                    ...typeArgs.slice(srcUnboundedTupleIndex),
+                ];
+                srcUnboundedTupleIndex++;
+            }
+            // "Smear" the tuple type across type argument slots following the variadic type var.
+            while (typeArgs.length < typeParameters.length) {
+                typeArgs = [
+                    ...typeArgs.slice(0, srcUnboundedTupleIndex + 1),
+                    { node: typeArgs[srcUnboundedTupleIndex].node, type: srcUnboundedTupleType },
+                    ...typeArgs.slice(srcUnboundedTupleIndex + 1),
+                ];
+            }
+        }
         // Do we need to adjust the type arguments to map to a variadic type
-        // param at the end of the list?
+        // param somewhere in the list?
         if (variadicIndex >= 0) {
             const variadicTypeVar = typeParameters[variadicIndex];
             if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
@@ -4485,26 +4539,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ];
             }
         }
-        if (!typeParameters.some((typeVar) => typeVar.details.isVariadic && !typeVar.isVariadicInUnion)) {
-            let minTypeArgCount = typeParameters.length;
-            const firstNonDefaultParam = typeParameters.findIndex((param) => !!param.details.defaultType);
-            if (firstNonDefaultParam >= 0) {
-                minTypeArgCount = firstNonDefaultParam;
-            }
-            if (typeArgs.length > typeParameters.length) {
-                addError(localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
-                    name: printType(baseType),
-                    expected: typeParameters.length,
-                    received: typeArgs.length,
-                }), typeArgs[typeParameters.length].node);
-            }
-            else if (typeArgs.length < minTypeArgCount) {
-                addError(localize_1.Localizer.Diagnostic.typeArgsTooFew().format({
-                    name: printType(baseType),
-                    expected: typeParameters.length,
-                    received: typeArgs.length,
-                }), node.items[node.items.length - 1]);
-            }
+        let minTypeArgCount = typeParameters.length;
+        const firstDefaultParamIndex = typeParameters.findIndex((param) => !!param.details.defaultType);
+        if (firstDefaultParamIndex >= 0) {
+            minTypeArgCount = firstDefaultParamIndex;
+        }
+        if (typeArgs.length > typeParameters.length) {
+            addError(localize_1.Localizer.Diagnostic.typeArgsTooMany().format({
+                name: printType(baseType),
+                expected: typeParameters.length,
+                received: typeArgs.length,
+            }), typeArgs[typeParameters.length].node);
+        }
+        else if (typeArgs.length < minTypeArgCount) {
+            addError(localize_1.Localizer.Diagnostic.typeArgsTooFew().format({
+                name: printType(baseType),
+                expected: typeParameters.length,
+                received: typeArgs.length,
+            }), node.items[node.items.length - 1]);
         }
         // Handle the mypy_extensions.FlexibleAlias type specially.
         if ((0, types_1.isInstantiableClass)(baseType) &&
@@ -4520,7 +4572,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeList = typeArgs[index].typeList;
                 if (typeList) {
                     const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */);
-                    types_1.TypeBase.setSpecialForm(functionType);
                     typeList.forEach((paramType, paramIndex) => {
                         types_1.FunctionType.addParameter(functionType, {
                             category: 0 /* ParameterCategory.Simple */,
@@ -4530,7 +4581,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             hasDeclaredType: true,
                         });
                     });
-                    types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+                    if (typeList.length > 0) {
+                        types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+                    }
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
                 }
                 else if ((0, types_1.isParamSpec)(typeArgType)) {
@@ -4566,7 +4619,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if ((0, typeUtils_1.isEllipsisType)(typeArgType)) {
                     const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */ | 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */);
-                    types_1.TypeBase.setSpecialForm(functionType);
                     types_1.FunctionType.addDefaultParameters(functionType);
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext);
                 }
@@ -4602,6 +4654,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
+                if ((0, types_1.isUnpacked)(typeArgType) && !(0, types_1.isVariadicTypeVar)(param)) {
+                    const messageDiag = diag.createAddendum();
+                    messageDiag.addMessage(localize_1.Localizer.Diagnostic.unpackedArgInTypeArgument());
+                    messageDiag.addTextRange(typeArgs[index].node);
+                    typeArgType = types_1.UnknownType.create();
+                }
                 (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, typeArgType, diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
             }
         });
@@ -4691,7 +4749,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (types_1.ClassType.isSpecialBuiltIn(concreteSubtype, 'Literal')) {
                     // Special-case Literal types.
-                    return createLiteralType(node, flags);
+                    return createLiteralType(concreteSubtype, node, flags);
                 }
                 if (types_1.ClassType.isBuiltIn(concreteSubtype, 'InitVar')) {
                     // Special-case InitVar, used in data classes.
@@ -4917,7 +4975,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), node.baseExpression);
             return { type: types_1.UnknownType.create() };
         }
-        // Handle the special case where the object is a Tuple and
+        // Handle the special case where the object is a tuple and
         // the index is a constant number (integer) or a slice with integer
         // start and end values. In these cases, we can determine
         // the exact type by indexing into the tuple type array.
@@ -4950,39 +5008,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if ((0, types_1.isClassInstance)(valueType) && types_1.ClassType.isBuiltIn(valueType, 'slice')) {
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(baseType);
-                if (tupleType && tupleType.tupleTypeArguments && !(0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
-                    if (index0Expr.nodeType === 46 /* ParseNodeType.Slice */ && !index0Expr.stepValue) {
-                        // Create a local helper function to evaluate the slice parameters.
-                        const getSliceParameter = (expression, defaultValue) => {
-                            let value = defaultValue;
-                            if (expression) {
-                                const valType = getTypeOfExpression(expression).type;
-                                if ((0, types_1.isClassInstance)(valType) &&
-                                    types_1.ClassType.isBuiltIn(valType, 'int') &&
-                                    (0, typeUtils_1.isLiteralType)(valType) &&
-                                    typeof valType.literalValue === 'number') {
-                                    value = valType.literalValue;
-                                    if (value < 0) {
-                                        value = tupleType.tupleTypeArguments.length + value;
-                                    }
-                                }
-                                else {
-                                    value = -1;
-                                }
-                            }
-                            return value;
-                        };
-                        const startValue = getSliceParameter(index0Expr.startValue, 0);
-                        const endValue = getSliceParameter(index0Expr.endValue, tupleType.tupleTypeArguments.length);
-                        if (startValue >= 0 &&
-                            endValue > 0 &&
-                            endValue <= tupleType.tupleTypeArguments.length &&
-                            tupleClassType &&
-                            (0, types_1.isInstantiableClass)(tupleClassType)) {
-                            return {
-                                type: types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleType.tupleTypeArguments.slice(startValue, endValue))),
-                            };
-                        }
+                if (tupleType && index0Expr.nodeType === 46 /* ParseNodeType.Slice */) {
+                    const slicedTupleType = getSlicedTupleType(tupleType, index0Expr);
+                    if (slicedTupleType) {
+                        return { type: slicedTupleType };
                     }
                 }
             }
@@ -5102,6 +5131,51 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isIncomplete: !!callResult.isTypeIncomplete,
         };
     }
+    // Given a tuple type and a slice expression, determines the resulting
+    // type if it can be determined. If not, it returns undefined.
+    function getSlicedTupleType(tupleType, sliceNode) {
+        // We don't handle step values.
+        if (sliceNode.stepValue || !tupleType.tupleTypeArguments) {
+            return undefined;
+        }
+        const tupleTypeArgs = tupleType.tupleTypeArguments;
+        const startValue = getTupleSliceParameter(sliceNode.startValue, 0, tupleTypeArgs);
+        const endValue = getTupleSliceParameter(sliceNode.endValue, tupleTypeArgs.length, tupleTypeArgs);
+        if (startValue === undefined || endValue === undefined || endValue < startValue) {
+            return undefined;
+        }
+        const slicedTypeArgs = tupleTypeArgs.slice(startValue, endValue);
+        return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleType, slicedTypeArgs));
+    }
+    function getTupleSliceParameter(expression, defaultValue, tupleTypeArgs) {
+        let value = defaultValue;
+        if (expression) {
+            const valType = getTypeOfExpression(expression).type;
+            if (!(0, types_1.isClassInstance)(valType) || !types_1.ClassType.isBuiltIn(valType, 'int') || !(0, typeUtils_1.isLiteralType)(valType)) {
+                return undefined;
+            }
+            value = valType.literalValue;
+            const unboundedIndex = tupleTypeArgs.findIndex((typeArg) => typeArg.isUnbounded || (0, types_1.isVariadicTypeVar)(typeArg.type));
+            if (value < 0) {
+                value = tupleTypeArgs.length + value;
+                if (value < 0) {
+                    return undefined;
+                }
+                else if (unboundedIndex >= 0 && value <= unboundedIndex) {
+                    return undefined;
+                }
+            }
+            else {
+                if (value > tupleTypeArgs.length) {
+                    return undefined;
+                }
+                else if (unboundedIndex >= 0 && value > unboundedIndex) {
+                    return undefined;
+                }
+            }
+        }
+        return value;
+    }
     function getTypeArgs(node, flags, options) {
         const typeArgs = [];
         let adjFlags = flags;
@@ -5117,7 +5191,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
                 adjFlags |= 131072 /* EvaluatorFlags.DisallowClassVar */ | 16 /* EvaluatorFlags.DisallowFinal */;
             }
-            adjFlags |= 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */;
+            adjFlags |= 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */ | 134217728 /* EvaluatorFlags.AllowConcatenate */;
         }
         // Create a local function that validates a single type argument.
         const getTypeArgTypeResult = (expr, argIndex) => {
@@ -5173,13 +5247,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeResult = getTypeArgTypeResult(arg.valueExpression, index);
                 if (arg.argumentCategory !== 0 /* ArgumentCategory.Simple */) {
                     if (arg.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
-                        if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicUnpacked) {
-                            typeResult.type = types_1.TypeVarType.cloneForUnpacked(typeResult.type);
-                        }
-                        else if ((0, types_1.isInstantiableClass)(typeResult.type) &&
-                            !typeResult.type.includeSubclasses &&
-                            (0, typeUtils_1.isTupleClass)(typeResult.type)) {
-                            typeResult.type = types_1.ClassType.cloneForUnpacked(typeResult.type);
+                        if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass) || index === 0) {
+                            if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicUnpacked) {
+                                typeResult.type = types_1.TypeVarType.cloneForUnpacked(typeResult.type);
+                            }
+                            else if ((0, types_1.isInstantiableClass)(typeResult.type) &&
+                                !typeResult.type.includeSubclasses &&
+                                (0, typeUtils_1.isTupleClass)(typeResult.type)) {
+                                typeResult.type = types_1.ClassType.cloneForUnpacked(typeResult.type);
+                            }
+                            else {
+                                addError(localize_1.Localizer.Diagnostic.unpackNotAllowed(), arg.valueExpression);
+                            }
                         }
                     }
                 }
@@ -5422,7 +5501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             baseTypeResult = getTypeOfLambdaForCall(node, inferenceContext);
         }
         else {
-            baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */ | (flags & 4 /* EvaluatorFlags.AllowForwardReferences */));
+            baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */ | (flags & 4 /* EvaluatorFlags.AllowForwardReferences */));
         }
         const argList = ParseTreeUtils.getArgumentsByRuntimeOrder(node).map((arg) => {
             const functionArg = {
@@ -5553,7 +5632,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         function getLambdaType() {
-            return getTypeOfExpression(node.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */, (0, typeUtils_1.makeInferenceContext)(expectedType));
+            return getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */, (0, typeUtils_1.makeInferenceContext)(expectedType));
         }
         // If one or more of the arguments are incomplete, use speculative mode
         // for the lambda evaluation because it may need to be reevaluated once
@@ -5563,7 +5642,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             : getLambdaType();
         // If bidirectional type inference failed, use normal type inference instead.
         if (typeResult.typeErrors) {
-            typeResult = getTypeOfExpression(node.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */);
+            typeResult = getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
         }
         return typeResult;
     }
@@ -5836,9 +5915,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 resultType = types_1.UnknownType.create();
             }
             return {
-                type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType) : resultType,
+                type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType, /* includeSubclasses */ false) : resultType,
                 bindToSelfType: bindToType
-                    ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(bindToType, /* isClsParam */ false), bindToType.condition)
+                    ? types_1.TypeBase.cloneForCondition((0, typeUtils_1.synthesizeTypeVarForSelfCls)(types_1.ClassType.cloneIncludeSubclasses(bindToType, /* includeSubclasses */ false), 
+                    /* isClsParam */ false), bindToType.condition)
                     : undefined,
             };
         }
@@ -6334,7 +6414,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
         recursionCount++;
-        if (types_1.TypeBase.isSpecialForm(callTypeResult.type)) {
+        // Special forms are not callable.
+        if (callTypeResult.type.specialForm) {
             const exprNode = errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode;
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
                 type: printType(callTypeResult.type, { expandTypeAlias: true }),
@@ -6430,18 +6511,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), errorNode);
             return { returnType: undefined, argumentErrors: true };
         }
-        // Check for an attempt to invoke an abstract static or class method.
-        if (expandedCallType.boundToType &&
-            (0, types_1.isInstantiableClass)(expandedCallType.boundToType) &&
-            !expandedCallType.boundToType.includeSubclasses) {
-            if (types_1.FunctionType.isAbstractMethod(expandedCallType)) {
-                if (types_1.FunctionType.isStaticMethod(expandedCallType) || types_1.FunctionType.isClassMethod(expandedCallType)) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.abstractMethodInvocation().format({
-                        method: expandedCallType.details.name,
-                    }), errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode);
-                }
-            }
-        }
         let effectiveTypeVarContext = typeVarContext;
         if (!effectiveTypeVarContext) {
             // If a typeVarContext wasn't provided by the caller, allocate one here.
@@ -6494,6 +6563,41 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             specializedInitSelfType: functionResult.specializedInitSelfType,
         };
     }
+    function isMethodUnimplementedAbstract(functionType) {
+        let isAbstract = false;
+        // If the function is part of a protocol, it's automatically considered abstract
+        // unless it's located in a stub, in which case it must be explicitly marked as
+        // abstract.
+        if (types_1.FunctionType.isAbstractMethod(functionType)) {
+            isAbstract = true;
+        }
+        else if (functionType.details.methodClass &&
+            types_1.ClassType.isProtocolClass(functionType.details.methodClass) &&
+            functionType.details.declaration &&
+            !AnalyzerNodeInfo.getFileInfo(functionType.details.declaration.node).isStubFile) {
+            isAbstract = true;
+        }
+        if (!isAbstract) {
+            return false;
+        }
+        // Determine if the method is unimplemented by looking at whether its
+        // body contains a "trivial" implementation.
+        let implementation = functionType;
+        // If this is an overloaded method, consider the implementation.
+        if (functionType.overloaded) {
+            implementation = types_1.OverloadedFunctionType.getImplementation(functionType.overloaded);
+            // If there is no implementation and it's in a stub file, assume it's not abstract.
+            if (!implementation) {
+                return (functionType.details.declaration !== undefined &&
+                    !AnalyzerNodeInfo.getFileInfo(functionType.details.declaration.node).isStubFile);
+            }
+        }
+        if (!implementation.details.declaration) {
+            return false;
+        }
+        const decl = implementation.details.declaration;
+        return ParseTreeUtils.isSuiteEmpty(decl.node.suite) || methodAlwaysRaisesNotImplemented(decl);
+    }
     function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
         // Handle the 'cast' call as a special case.
@@ -6610,14 +6714,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (className === 'NewType') {
                 return { returnType: createNewType(errorNode, argList) };
             }
-            if (className === 'Protocol' ||
-                className === 'Generic' ||
-                className === 'Callable' ||
-                className === 'Concatenate' ||
-                className === 'Type') {
+            if (types_1.ClassType.isSpecialFormClass(expandedCallType)) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIntantiable().format({ type: className }), errorNode);
-                return { returnType: types_1.AnyType.create(), argumentErrors: true };
+                return { returnType: types_1.UnknownType.create(), argumentErrors: true };
             }
             if ((0, types_1.isClass)(unexpandedCallType) && (0, enums_1.isKnownEnumType)(className)) {
                 return {
@@ -7727,6 +7827,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let specializedInitSelfType;
         let anyOrUnknownArgument;
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
+        // Check for an attempt to invoke an unimplemented abstract method.
+        if (type.boundToType && !type.boundToType.includeSubclasses && isMethodUnimplementedAbstract(type)) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.abstractMethodInvocation().format({
+                method: type.details.name,
+            }), errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode);
+        }
         if (type.boundTypeVarScopeId) {
             // If the function was bound to a class or object and was a constructor, a
             // static method or a class method, it's possible that some of that class's
@@ -8211,8 +8317,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     ? 512 /* EvaluatorFlags.AllowMissingTypeArgs */ |
                         8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
                         32 /* EvaluatorFlags.DisallowParamSpec */ |
-                        64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                        16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */
+                        64 /* EvaluatorFlags.DisallowTypeVarTuple */
                     : 2 /* EvaluatorFlags.DoNotSpecialize */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
                 argType = exprTypeResult.type;
@@ -8331,8 +8436,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        let assignTypeFlags = skipSolveTypeVars ? 8 /* AssignTypeFlags.SkipSolveTypeVars */ : 0 /* AssignTypeFlags.Default */;
+        if (argParam.isinstanceParam) {
+            assignTypeFlags |= 32768 /* AssignTypeFlags.AllowIsinstanceSpecialForms */;
+        }
         if (!assignType(argParam.paramType, argType, diag.createAddendum(), typeVarContext, 
-        /* srcTypeVarContext */ undefined, skipSolveTypeVars ? 8 /* AssignTypeFlags.SkipSolveTypeVars */ : undefined)) {
+        /* srcTypeVarContext */ undefined, assignTypeFlags)) {
             // Mismatching parameter types are common in untyped code; don't bother spending time
             // printing types if the diagnostic is disabled.
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
@@ -8593,6 +8702,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     addError(localize_1.Localizer.Diagnostic.typeVarTupleUnknownParam().format({ name: ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.value) || '?' }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
                 }
             }
+            else {
+                addError(localize_1.Localizer.Diagnostic.typeVarTupleConstraints(), argList[i].valueExpression || errorNode);
+            }
         }
         return typeVar;
     }
@@ -8653,7 +8765,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getParamSpecDefaultType(node) {
         const functionType = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
-        types_1.TypeBase.setSpecialForm(functionType);
         if (node.nodeType === 18 /* ParseNodeType.Ellipsis */) {
             types_1.FunctionType.addDefaultParameters(functionType);
             return functionType;
@@ -8669,6 +8780,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type: (0, typeUtils_1.convertToInstance)(typeResult.type),
                 });
             });
+            if (node.entries.length > 0) {
+                types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+            }
             // Update the type cache so we don't attempt to re-evaluate this node.
             // The type doesn't matter, so use Any.
             writeTypeCache(node, { type: types_1.AnyType.create() }, /* flags */ undefined);
@@ -8686,7 +8800,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 functionType.details.paramSpec = typeResult.type;
                 return functionType;
             }
-            if ((0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ellipsis')) {
+            if ((0, types_1.isClassInstance)(typeResult.type) &&
+                types_1.ClassType.isBuiltIn(typeResult.type, ['EllipsisType', 'ellipsis'])) {
                 types_1.FunctionType.addDefaultParameters(functionType);
                 return functionType;
             }
@@ -8842,17 +8957,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isBaseClassAny = true;
         }
         if (!(0, types_1.isInstantiableClass)(baseClass)) {
-            addError(localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
             return undefined;
         }
         if (types_1.ClassType.isProtocolClass(baseClass) || types_1.ClassType.isTypedDictClass(baseClass)) {
-            addError(localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
         }
         else if (baseClass.literalValue !== undefined) {
-            addError(localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
-        }
-        else if (types_1.ClassType.isNewTypeClass(baseClass)) {
-            addError(localize_1.Localizer.Diagnostic.newTypeNewTypeClass(), argList[1].node || errorNode);
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.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 */;
@@ -9786,9 +9898,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // or the final expression contain an "await" operator anywhere within
         // the expression, it is treated as an async generator.
         let isAsync = node.forIfNodes.some((comp) => {
-            return ((comp.nodeType === 33 /* ParseNodeType.ListComprehensionFor */ && comp.isAsync) ||
-                (comp.nodeType === 34 /* ParseNodeType.ListComprehensionIf */ &&
-                    ParseTreeUtils.containsAwaitNode(comp.testExpression)));
+            if (comp.nodeType === 33 /* ParseNodeType.ListComprehensionFor */ && comp.isAsync) {
+                return true;
+            }
+            return ParseTreeUtils.containsAwaitNode(comp);
         });
         let type = types_1.UnknownType.create();
         if (ParseTreeUtils.containsAwaitNode(node.expression)) {
@@ -9803,14 +9916,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeErrors = true;
         }
         const elementType = elementTypeResult.type;
-        // Handle the special case where a generator function (e.g. `(await x for x in y)`)
-        // is expected to be an AsyncGenerator.
-        if (!isAsync &&
-            inferenceContext &&
-            (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
-            types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'AsyncGenerator')) {
-            isAsync = true;
-        }
         const builtInIteratorType = getTypingType(node, isAsync ? 'AsyncGenerator' : 'Generator');
         if (builtInIteratorType && (0, types_1.isInstantiableClass)(builtInIteratorType)) {
             type = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(builtInIteratorType, isAsync ? [elementType, getNoneType()] : [elementType, getNoneType(), getNoneType()], 
@@ -9997,9 +10102,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // to two arguments.The first argument, if present, should be an ellipsis,
     // a ParamSpec, a Concatenate, or a list of positional parameter types.
     // The second argument, if present, should specify the return type.
-    function createCallableType(typeArgs, errorNode) {
+    function createCallableType(classType, typeArgs, errorNode) {
         const functionType = types_1.FunctionType.createInstantiable(0 /* FunctionTypeFlags.None */);
-        types_1.TypeBase.setSpecialForm(functionType);
+        functionType.specialForm = classType;
         functionType.details.declaredReturnType = types_1.UnknownType.create();
         functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(errorNode);
         if (typeArgs && typeArgs.length > 0) {
@@ -10132,9 +10237,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addExpectedClassDiagnostic(typeArg0Type, typeArgs[0].node);
             typeArg0Type = types_1.UnknownType.create();
         }
-        const optionalType = (0, types_1.combineTypes)([typeArg0Type, noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create()]);
-        if ((0, types_1.isUnion)(optionalType)) {
-            types_1.TypeBase.setSpecialForm(optionalType);
+        let optionalType = (0, types_1.combineTypes)([typeArg0Type, noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create()]);
+        if (unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
+            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, unionClassType);
         }
         return optionalType;
     }
@@ -10145,15 +10250,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return types_1.UnknownType.create();
     }
-    function cloneBuiltinClassWithLiteral(node, builtInName, value) {
+    function cloneBuiltinClassWithLiteral(node, literalClassType, builtInName, value) {
         const type = getBuiltInType(node, builtInName);
         if ((0, types_1.isInstantiableClass)(type)) {
-            return types_1.ClassType.cloneWithLiteral(type, value);
+            const literalType = types_1.ClassType.cloneWithLiteral(type, value);
+            literalType.specialForm = literalClassType;
+            return literalType;
         }
         return types_1.UnknownType.create();
     }
     // Creates a type that represents a Literal.
-    function createLiteralType(node, flags) {
+    function createLiteralType(classType, node, flags) {
         if (node.items.length === 0) {
             addError(localize_1.Localizer.Diagnostic.literalEmptyArgs(), node.baseExpression);
             return types_1.UnknownType.create();
@@ -10176,33 +10283,36 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const isBytes = (itemExpr.strings[0].token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
                 const value = itemExpr.strings.map((s) => s.value).join('');
                 if (isBytes) {
-                    type = cloneBuiltinClassWithLiteral(node, 'bytes', value);
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'bytes', value);
                 }
                 else {
-                    type = cloneBuiltinClassWithLiteral(node, 'str', value);
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'str', value);
                 }
             }
             else if (itemExpr.nodeType === 40 /* ParseNodeType.Number */) {
                 if (!itemExpr.isImaginary && itemExpr.isInteger) {
-                    type = cloneBuiltinClassWithLiteral(node, 'int', itemExpr.value);
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'int', itemExpr.value);
                 }
             }
             else if (itemExpr.nodeType === 11 /* ParseNodeType.Constant */) {
                 if (itemExpr.constType === 33 /* KeywordType.True */) {
-                    type = cloneBuiltinClassWithLiteral(node, 'bool', true);
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'bool', true);
                 }
                 else if (itemExpr.constType === 15 /* KeywordType.False */) {
-                    type = cloneBuiltinClassWithLiteral(node, 'bool', false);
+                    type = cloneBuiltinClassWithLiteral(node, classType, 'bool', false);
                 }
                 else if (itemExpr.constType === 26 /* KeywordType.None */) {
                     type = noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create();
                 }
             }
-            else if (itemExpr.nodeType === 55 /* ParseNodeType.UnaryOperation */ &&
-                itemExpr.operator === 33 /* OperatorType.Subtract */) {
-                if (itemExpr.expression.nodeType === 40 /* ParseNodeType.Number */) {
-                    if (!itemExpr.expression.isImaginary && itemExpr.expression.isInteger) {
-                        type = cloneBuiltinClassWithLiteral(node, 'int', -itemExpr.expression.value);
+            else if (itemExpr.nodeType === 55 /* ParseNodeType.UnaryOperation */) {
+                if (itemExpr.operator === 33 /* OperatorType.Subtract */ || itemExpr.operator === 0 /* OperatorType.Add */) {
+                    if (itemExpr.expression.nodeType === 40 /* ParseNodeType.Number */) {
+                        if (!itemExpr.expression.isImaginary && itemExpr.expression.isInteger) {
+                            type = cloneBuiltinClassWithLiteral(node, classType, 'int', itemExpr.operator === 33 /* OperatorType.Subtract */
+                                ? -itemExpr.expression.value
+                                : itemExpr.expression.value);
+                        }
                     }
                 }
             }
@@ -10451,7 +10561,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeArgs[0].type;
     }
-    function createConcatenateType(errorNode, classType, typeArgs) {
+    function createConcatenateType(errorNode, classType, typeArgs, flags) {
+        if ((flags & 134217728 /* EvaluatorFlags.AllowConcatenate */) === 0) {
+            addError(localize_1.Localizer.Diagnostic.concatenateContext(), errorNode);
+            return types_1.AnyType.create();
+        }
         if (!typeArgs || typeArgs.length === 0) {
             addError(localize_1.Localizer.Diagnostic.concatenateTypeArgsMissing(), errorNode);
         }
@@ -10497,7 +10611,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Creates one of several "special" types that are defined in typing.pyi
     // but not declared in their entirety. This includes the likes of "Tuple",
     // "Dict", etc.
-    function createSpecialType(classType, typeArgs, paramLimit, allowParamSpec = false, isCallable = false) {
+    function createSpecialType(classType, typeArgs, paramLimit, allowParamSpec = false, isSpecialForm = true) {
         const isTupleTypeParam = types_1.ClassType.isTupleClass(classType);
         if (typeArgs) {
             if (isTupleTypeParam && typeArgs.length === 1 && typeArgs[0].isEmptyTupleShorthand) {
@@ -10601,14 +10715,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             returnType = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== undefined);
         }
-        if (!isCallable) {
-            types_1.TypeBase.setSpecialForm(returnType);
+        if (isSpecialForm) {
+            returnType = types_1.TypeBase.cloneAsSpecialForm(returnType, classType);
         }
         return returnType;
     }
     // Unpacks the index expression for a "Union[X, Y, Z]" type annotation.
     function createUnionType(classType, errorNode, typeArgs, flags) {
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         const types = [];
+        let allowSingleTypeArg = false;
         if (!typeArgs) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
@@ -10630,15 +10746,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             // If this is an unpacked tuple, explode out the individual items.
             if ((0, types_1.isUnpackedClass)(typeArg.type) && typeArg.type.tupleTypeArguments) {
-                typeArg.type.tupleTypeArguments.forEach((tupleTypeArg) => {
-                    types.push((0, typeUtils_1.convertToInstantiable)(tupleTypeArg.type));
-                });
+                if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
+                    typeArg.type.tupleTypeArguments.forEach((tupleTypeArg) => {
+                        types.push((0, typeUtils_1.convertToInstantiable)(tupleTypeArg.type));
+                    });
+                    allowSingleTypeArg = true;
+                }
+                else {
+                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionUnpackedTuple(), errorNode);
+                    types.push(types_1.UnknownType.create());
+                }
             }
             else {
-                // If this is an unpacked TypeVar, note that it is in a union so we can differentiate
-                // between Unpack[Vs] and Union[Unpack[Vs]].
                 if ((0, types_1.isTypeVar)(typeArgType) && (0, types_1.isUnpackedVariadicTypeVar)(typeArgType)) {
-                    typeArgType = types_1.TypeVarType.cloneForUnpacked(typeArgType, /* isInUnion */ true);
+                    if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
+                        // If this is an unpacked TypeVar, note that it is in a union so we can
+                        // differentiate between Unpack[Vs] and Union[Unpack[Vs]].
+                        typeArgType = types_1.TypeVarType.cloneForUnpacked(typeArgType, /* isInUnion */ true);
+                        allowSingleTypeArg = true;
+                    }
+                    else {
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionUnpackedTypeVarTuple(), errorNode);
+                        typeArgType = types_1.UnknownType.create();
+                    }
                 }
                 types.push(typeArgType);
             }
@@ -10646,14 +10776,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Validate that we received at least two type arguments. One type argument
         // is allowed if it's an unpacked variadic type var or tuple. None is also allowed
         // since it is used to define NoReturn in typeshed stubs).
-        if (types.length === 1) {
-            if (!(0, types_1.isVariadicTypeVar)(types[0]) && !(0, types_1.isUnpacked)(types[0]) && !(0, typeUtils_1.isNoneInstance)(types[0])) {
-                addError(localize_1.Localizer.Diagnostic.unionTypeArgCount(), errorNode);
-            }
+        if (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0])) {
+            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionTypeArgCount(), errorNode);
         }
-        const unionType = (0, types_1.combineTypes)(types);
-        if ((0, types_1.isUnion)(unionType)) {
-            types_1.TypeBase.setSpecialForm(unionType);
+        let unionType = (0, types_1.combineTypes)(types);
+        if (unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
+            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, unionClassType);
         }
         return unionType;
     }
@@ -10744,11 +10872,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
-        const typeAlias = types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), fileInfo.moduleName, fileInfo.fileUri, typeAliasScopeId, isPep695Syntax, typeParameters.length > 0 ? typeParameters : undefined);
+        let typeAlias = types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), fileInfo.moduleName, fileInfo.fileUri, typeAliasScopeId, isPep695Syntax, typeParameters.length > 0 ? typeParameters : undefined);
         // All PEP 695 type aliases are special forms because they are
         // TypeAliasType objects at runtime.
         if (isPep695Syntax || isPep695TypeVarType) {
-            typeAlias.flags |= 8 /* TypeFlags.SpecialForm */;
+            const typeAliasTypeClass = getTypingType(errorNode, 'TypeAliasType');
+            if (typeAliasTypeClass && (0, types_1.isInstantiableClass)(typeAliasTypeClass)) {
+                typeAlias = types_1.TypeBase.cloneAsSpecialForm(typeAlias, typeAliasTypeClass);
+            }
         }
         return typeAlias;
     }
@@ -10759,6 +10890,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* typeSourceId */ 0, 
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined);
+        if (aliasMapEntry.isSpecialForm) {
+            specialClassType.details.flags |= 1073741824 /* 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) {
@@ -10816,28 +10950,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const assignedName = nameNode.value;
         const specialTypes = new Map([
             ['Tuple', { alias: 'tuple', module: 'builtins' }],
-            ['Generic', { alias: '', module: 'builtins' }],
-            ['Protocol', { alias: '', module: 'builtins' }],
-            ['Callable', { alias: '', module: 'builtins' }],
+            ['Generic', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Protocol', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Callable', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['Type', { alias: 'type', module: 'builtins' }],
-            ['ClassVar', { alias: '', module: 'builtins' }],
-            ['Final', { alias: '', module: 'builtins' }],
-            ['Literal', { alias: '', module: 'builtins' }],
+            ['ClassVar', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Final', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Literal', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['TypedDict', { alias: '_TypedDict', module: 'self' }],
-            ['Union', { alias: '', module: 'builtins' }],
-            ['Optional', { alias: '', module: 'builtins' }],
-            ['Annotated', { alias: '', module: 'builtins' }],
-            ['TypeAlias', { alias: '', module: 'builtins' }],
-            ['Concatenate', { alias: '', module: 'builtins' }],
-            ['TypeGuard', { alias: '', module: 'builtins' }],
-            ['Unpack', { alias: '', module: 'builtins' }],
-            ['Required', { alias: '', module: 'builtins' }],
-            ['NotRequired', { alias: '', module: 'builtins' }],
-            ['Self', { alias: '', module: 'builtins' }],
-            ['NoReturn', { alias: '', module: 'builtins' }],
-            ['Never', { alias: '', module: 'builtins' }],
-            ['LiteralString', { alias: '', module: 'builtins' }],
-            ['ReadOnly', { alias: '', module: 'builtins' }],
+            ['Union', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Optional', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Annotated', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['TypeAlias', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Concatenate', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['TypeGuard', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Unpack', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Required', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['NotRequired', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Self', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['NoReturn', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Never', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['LiteralString', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['ReadOnly', { alias: '', module: 'builtins', isSpecialForm: true }],
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
@@ -11005,7 +11139,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // only if the evaluated type is an instantiable type.
                     if (!isSpeculativeTypeAlias || isLegalImplicitTypeAliasType(rightHandType)) {
                         // If this is a type alias, record its name based on the assignment target.
-                        rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, node.rightExpression, 
+                        rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, typeAliasNameNode, 
                         /* isPep695Syntax */ false, 
                         /* isPep695TypeVarType */ false);
                         (0, debug_1.assert)(typeAliasTypeVar !== undefined);
@@ -11049,7 +11183,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     callLeftNode.leftExpression.nodeType === 38 /* ParseNodeType.Name */)) {
                 // See if this is a call to TypedDict. We want to support
                 // recursive type references in a TypedDict call.
-                const callType = getTypeOfExpression(callLeftNode, 16777218 /* EvaluatorFlags.CallBaseDefaults */).type;
+                const callType = getTypeOfExpression(callLeftNode, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
                 if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'TypedDict')) {
                     return true;
                 }
@@ -11106,7 +11240,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (aliasTypeResult.isIncomplete) {
             isIncomplete = true;
         }
-        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, isPep695Syntax, 
+        aliasType = transformTypeForTypeAlias(aliasType, nameNode, nameNode, isPep695Syntax, 
         /* isPep695TypeVarType */ true, typeParameters, typeParamNodes);
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(valueNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
@@ -11211,8 +11345,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 262144 /* EvaluatorFlags.DisallowNakedGeneric */ |
                 2048 /* EvaluatorFlags.DisallowTypeVarsWithScopeId */ |
                 8192 /* EvaluatorFlags.AssociateTypeVarsWithCurrentScope */ |
-                16384 /* EvaluatorFlags.EnforceTypeVarVarianceConsistency */ |
-                16777216 /* EvaluatorFlags.TreatPep695TypeAliasAsObject */;
+                16384 /* EvaluatorFlags.EnforceTypeVarVarianceConsistency */;
             if (fileInfo.isStubFile) {
                 exprFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */;
             }
@@ -11241,7 +11374,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     // Any is allowed as a base class. Remove its "special form" flag to avoid
                     // false positive errors.
-                    if ((0, types_1.isAny)(argType) && types_1.TypeBase.isSpecialForm(argType)) {
+                    if ((0, types_1.isAny)(argType) && argType.specialForm) {
                         argType = types_1.AnyType.create();
                     }
                     if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
@@ -11296,6 +11429,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 addError(localize_1.Localizer.Diagnostic.baseClassCircular(), arg);
                                 argType = types_1.UnknownType.create();
                             }
+                            // If the class is attempting to derive from a TypeAliasType,
+                            // generate an error.
+                            if (argType.specialForm && types_1.ClassType.isBuiltIn(argType.specialForm, 'TypeAliasType')) {
+                                addError(localize_1.Localizer.Diagnostic.typeAliasTypeBaseClass(), arg);
+                                argType = types_1.UnknownType.create();
+                            }
                         }
                     }
                     if ((0, types_1.isUnknown)(argType)) {
@@ -13365,7 +13504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         nodeToEvaluate = parent;
                         continue;
                     }
-                    flags = 16777218 /* EvaluatorFlags.CallBaseDefaults */;
+                    flags = 2 /* EvaluatorFlags.CallBaseDefaults */;
                     break;
                 }
             }
@@ -13713,7 +13852,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const aliasedName = classType.aliasName || classType.details.name;
             switch (aliasedName) {
                 case 'Callable': {
-                    return { type: createCallableType(typeArgs, errorNode) };
+                    return { type: createCallableType(classType, typeArgs, errorNode) };
                 }
                 case 'Never': {
                     if (typeArgs && typeArgs.length > 0) {
@@ -13731,7 +13870,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return { type: createOptionalType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Type': {
-                    let typeType = createSpecialType(classType, typeArgs, 1);
+                    let typeType = createSpecialType(classType, typeArgs, 1, 
+                    /* allowParamSpec */ undefined, 
+                    /* isSpecialForm */ false);
                     if ((0, types_1.isInstantiableClass)(typeType)) {
                         typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
                     }
@@ -13769,7 +13910,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     break;
                 }
                 case 'Tuple': {
-                    return { type: createSpecialType(classType, typeArgs, /* paramLimit */ undefined) };
+                    return {
+                        type: createSpecialType(classType, typeArgs, 
+                        /* paramLimit */ undefined, 
+                        /* allowParamSpec */ false, 
+                        /* isSpecialForm */ false),
+                    };
                 }
                 case 'Union': {
                     return { type: createUnionType(classType, errorNode, typeArgs, flags) };
@@ -13784,7 +13930,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return createAnnotatedType(errorNode, typeArgs);
                 }
                 case 'Concatenate': {
-                    return { type: createConcatenateType(errorNode, classType, typeArgs) };
+                    return { type: createConcatenateType(errorNode, classType, typeArgs, flags) };
                 }
                 case 'TypeGuard': {
                     return { type: createTypeGuardType(errorNode, classType, typeArgs, flags) };
@@ -13828,7 +13974,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (typeClassType && (0, types_1.isInstantiableClass)(typeClassType)) {
                     let typeType = createSpecialType(typeClassType, typeArgs, 1, 
                     /* allowParamSpec */ undefined, 
-                    /* isCallable */ true);
+                    /* isSpecialForm */ false);
                     if ((0, types_1.isInstantiableClass)(typeType)) {
                         typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
                     }
@@ -13842,7 +13988,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type: createSpecialType(classType, typeArgs, 
                     /* paramLimit */ undefined, 
                     /* allowParamSpec */ undefined, 
-                    /* isCallable */ true),
+                    /* isSpecialForm */ false),
                 };
             }
         }
@@ -13857,9 +14003,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const variadicTypeParamIndex = typeParameters.findIndex((param) => (0, types_1.isVariadicTypeVar)(param));
         if (typeArgs) {
             let minTypeArgCount = typeParameters.length;
-            const firstNonDefaultParam = typeParameters.findIndex((param) => !!param.details.defaultType);
-            if (firstNonDefaultParam >= 0) {
-                minTypeArgCount = firstNonDefaultParam;
+            const firstDefaultParamIndex = typeParameters.findIndex((param) => !!param.details.defaultType);
+            if (firstDefaultParamIndex >= 0) {
+                minTypeArgCount = firstDefaultParamIndex;
             }
             // Classes that accept inlined type dict type args allow only one.
             if (typeArgs[0].inlinedTypeDict) {
@@ -13957,7 +14103,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (typeParam.details.isParamSpec) {
                     const typeArg = typeArgs[index];
                     const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */);
-                    types_1.TypeBase.setSpecialForm(functionType);
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         types_1.FunctionType.addDefaultParameters(functionType);
                         functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
@@ -13975,6 +14120,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 hasDeclaredType: true,
                             });
                         });
+                        if (typeArg.typeList.length > 0) {
+                            types_1.FunctionType.addPositionOnlyParameterSeparator(functionType);
+                        }
                         typeArgTypes.push(functionType);
                         typeVarContext.setTypeVarType(typeParam, (0, typeUtils_1.convertTypeToParamSpecValue)(functionType));
                         return;
@@ -14838,7 +14986,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // Special-case calls to certain built-in type functions.
                 if (((_a = resolvedDecl.inferredTypeSource) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */) {
-                    const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 16777218 /* EvaluatorFlags.CallBaseDefaults */);
+                    const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
                     const callType = baseTypeResult.type;
                     const exemptBuiltins = [
                         'TypeVar',
@@ -15713,7 +15861,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function assignClassToSelf(destType, srcType, ignoreBaseClassVariance = true, recursionCount = 0) {
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
         (0, debug_1.assert)(destType.details.typeParameters.length > 0);
-        const diag = new diagnostic_1.DiagnosticAddendum();
         const typeVarContext = new typeVarContext_1.TypeVarContext();
         let isAssignable = true;
         destType.details.fields.forEach((symbol, name) => {
@@ -15734,7 +15881,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 types_1.ClassType.isPropertyClass(destMemberType) &&
                 (0, types_1.isClassInstance)(srcMemberType) &&
                 types_1.ClassType.isPropertyClass(srcMemberType)) {
-                if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, diag, typeVarContext, 
+                if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, 
+                /* diag */ undefined, typeVarContext, 
                 /* selfTypeVarContext */ undefined, recursionCount)) {
                     isAssignable = false;
                 }
@@ -15753,7 +15901,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         flags |= 1 /* AssignTypeFlags.EnforceInvariance */;
                     }
                 }
-                if (!assignType(destMemberType, srcMemberType, diag, typeVarContext, 
+                if (!assignType(destMemberType, srcMemberType, 
+                /* diag */ undefined, typeVarContext, 
                 /* srcTypeVarContext */ undefined, flags, recursionCount)) {
                     isAssignable = false;
                 }
@@ -16124,6 +16273,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (destType === srcType && !(0, typeUtils_1.requiresSpecialization)(destType)) {
             return true;
         }
+        // If the source type is a special form, use the literal special form
+        // class rather than the symbolic form.
+        if (srcType.specialForm) {
+            let isSpecialFormExempt = false;
+            // A few special forms that are normally not compatible with type[T]
+            // are compatible specifically in the context of isinstance and issubclass.
+            if ((flags & 32768 /* AssignTypeFlags.AllowIsinstanceSpecialForms */) !== 0) {
+                if (types_1.ClassType.isBuiltIn(srcType.specialForm, ['Callable', 'UnionType', 'Generic'])) {
+                    isSpecialFormExempt = true;
+                }
+            }
+            if (!isSpecialFormExempt) {
+                srcType = srcType.specialForm;
+            }
+        }
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return true;
         }
@@ -16321,7 +16485,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isAnyOrUnknown)(destType)) {
             return true;
         }
-        if ((0, types_1.isAnyOrUnknown)(srcType) && !types_1.TypeBase.isSpecialForm(srcType)) {
+        if ((0, types_1.isAnyOrUnknown)(srcType) && !srcType.specialForm) {
             const targetTypeVarContext = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destTypeVarContext : srcTypeVarContext;
             if (targetTypeVarContext) {
                 // If it's an ellipsis type, convert it to a regular "Any"
@@ -16426,8 +16590,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return false;
                     }
                 }
-                if (assignClass(destType, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
-                /* reportErrorsUsingObjType */ false)) {
+                if (!isSpecialFormClass(expandedSrcType, flags) &&
+                    assignClass(destType, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
+                    /* reportErrorsUsingObjType */ false)) {
                     return true;
                 }
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
@@ -16449,6 +16614,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, types_1.isClassInstance)(destType)) {
             if (types_1.ClassType.isBuiltIn(destType, 'type')) {
+                if ((0, types_1.isInstantiableClass)(srcType) && isSpecialFormClass(srcType, flags)) {
+                    return false;
+                }
                 if ((0, types_1.isAnyOrUnknown)(srcType) && (flags & 16 /* AssignTypeFlags.OverloadOverlapCheck */) !== 0) {
                     return false;
                 }
@@ -16550,7 +16718,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
-            else if ((0, types_1.isAnyOrUnknown)(concreteSrcType) && !types_1.TypeBase.isSpecialForm(concreteSrcType)) {
+            else if ((0, types_1.isAnyOrUnknown)(concreteSrcType) && !concreteSrcType.specialForm) {
                 return (flags & 16 /* AssignTypeFlags.OverloadOverlapCheck */) === 0;
             }
             else if ((0, types_1.isUnion)(concreteSrcType)) {
@@ -16851,6 +17019,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return true;
     }
+    function isSpecialFormClass(classType, flags) {
+        if ((flags & 32768 /* AssignTypeFlags.AllowIsinstanceSpecialForms */) !== 0) {
+            return false;
+        }
+        return types_1.ClassType.isSpecialFormClass(classType);
+    }
     // Determines whether a type is "subsumed by" (i.e. is a proper subtype of) one
     // of the other type.
     function isTypeSubsumedByOtherType(type, otherType, allowAnyToSubsume, recursionCount = 0) {
@@ -18616,6 +18790,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         isNodeReachable,
         isAsymmetricAccessorAssignment,
         suppressDiagnostics,
+        isSpecialFormClass,
         getDeclarationsForStringNode,
         getDeclarationsForNameNode,
         getTypeForDeclaration,
@@ -18658,6 +18833,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTupleClassType,
         getObjectType,
         getNoneType,
+        getUnionClassType,
         getBuiltInObject,
         getTypingType,
         assignTypeArguments,