@zzzen/pyright-internal 1.2.0-dev.20240901 → 1.2.0-dev.20240908

package/dist/analyzer/typeEvaluator.js

@@ -156,6 +156,11 @@ const maxInferFunctionReturnRecursionCount = 12;
 // (tuples, lists, sets, or dicts) which can lead to infinite type analysis.
 // This limits the depth.
 const maxInferredContainerDepth = 8;
+// If a tuple expression with no declared type contains a large number
+// of elements, it can cause performance issues. This value limits the
+// number of elements that will be included in the tuple type before
+// we default to tuple[Unknown, ...].
+const maxInferredTupleEntryCount = 256;
 // Maximum recursion amount when comparing two recursive type aliases.
 // Increasing this can greatly increase the time required to evaluate
 // two recursive type aliases that have the same definition. Decreasing
@@ -429,6 +434,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // context. For example, if it's a subexpression of an argument expression,
     // the associated parameter type might inform the expected type.
     function getExpectedType(node) {
+        // This is a primary entry point called by language server providers,
+        // and it might be called before any other type evaluation has occurred.
+        // Use this opportunity to do some initialization.
+        initializePrefetchedTypes(node);
         // Scan up the parse tree to find the top-most expression node
         // so we can evaluate the entire expression.
         let topExpression = node;
@@ -500,6 +509,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const anySpecialForm = types_1.AnyType.createSpecialForm();
                 if ((0, types_1.isAny)(anySpecialForm)) {
                     types_1.TypeBase.setSpecialForm(anySpecialForm, anyClass);
+                    if (isTypeFormSupported(node)) {
+                        types_1.TypeBase.setTypeForm(anySpecialForm, (0, typeUtils_1.convertToInstance)(anySpecialForm));
+                    }
                 }
             }
         }
@@ -588,7 +600,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // This is a helper function that implements the core of getTypeOfExpression.
     function getTypeOfExpressionCore(node, flags = 0 /* EvalFlags.None */, inferenceContext) {
-        var _a;
+        var _a, _b;
         let typeResult;
         let expectingInstantiable = (flags & 128 /* EvalFlags.InstantiableType */) !== 0;
         switch (node.nodeType) {
@@ -745,8 +757,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If this is a PEP 695 type alias, remove the special form so the type
         // printer prints it as its aliased type rather than TypeAliasType.
-        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
-            const specialForm = (_a = typeResult.type.props) === null || _a === void 0 ? void 0 : _a.specialForm;
+        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0 && ((_a = typeResult.type.props) === null || _a === void 0 ? void 0 : _a.typeForm) === undefined) {
+            const specialForm = (_b = typeResult.type.props) === null || _b === void 0 ? void 0 : _b.specialForm;
             if (specialForm && types_1.ClassType.isBuiltIn(specialForm, 'TypeAliasType')) {
                 typeResult.type = types_1.TypeBase.cloneAsSpecialForm(typeResult.type, undefined);
             }
@@ -889,10 +901,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return typeResult;
     }
     function getTypeOfStringList(node, flags) {
+        var _a;
         let typeResult;
-        if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0) {
+        if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0 && (flags & 1073741824 /* EvalFlags.TypeFormArg */) === 0) {
             return getTypeOfStringListAsType(node, flags);
         }
+        const isBytesNode = (node) => (node.d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
+        // Check for mixing of bytes and str, which is not allowed.
+        const firstStrIndex = node.d.strings.findIndex((str) => !isBytesNode(str));
+        const firstBytesIndex = node.d.strings.findIndex((str) => isBytesNode(str));
+        if (firstStrIndex >= 0 && firstBytesIndex >= 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.mixingBytesAndStr(), node.d.strings[Math.max(firstBytesIndex, firstStrIndex)]);
+            return { type: types_1.UnknownType.create() };
+        }
+        const isBytes = firstBytesIndex >= 0;
         let isLiteralString = true;
         let isIncomplete = false;
         node.d.strings.forEach((expr) => {
@@ -913,7 +935,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 isLiteralString = false;
             }
         });
-        const isBytes = (node.d.strings[0].d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
         // Don't create a literal type if it's an f-string.
         if (node.d.strings.some((str) => str.nodeType === 30 /* ParseNodeType.FormatString */)) {
             if (isLiteralString) {
@@ -935,6 +956,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 isIncomplete,
             };
         }
+        if (node.d.strings.length !== 1 ||
+            node.d.strings[0].nodeType !== 49 /* ParseNodeType.String */ ||
+            !isTypeFormSupported(node)) {
+            return typeResult;
+        }
+        // For performance reasons, do not attempt to treat the string literal
+        // as a TypeForm if it's going to fail anyway or is unlikely to be a
+        // TypeForm (really long, triple-quoted, etc.).
+        const stringNode = node.d.strings[0];
+        const tokenFlags = stringNode.d.token.flags;
+        const disallowedTokenFlags = 32 /* StringTokenFlags.Bytes */ | 8 /* StringTokenFlags.Raw */ | 64 /* StringTokenFlags.Format */ | 4 /* StringTokenFlags.Triplicate */;
+        const maxTypeFormStringLength = 256;
+        if ((tokenFlags & disallowedTokenFlags) !== 0 ||
+            stringNode.d.token.escapedValue.length >= maxTypeFormStringLength) {
+            return typeResult;
+        }
+        const typeFormResult = getTypeOfStringListAsType(node, flags);
+        if ((_a = typeFormResult.type.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+            typeResult.type = types_1.TypeBase.cloneWithTypeForm(typeResult.type, typeFormResult.type.props.typeForm);
+        }
         return typeResult;
     }
     function getTypeOfStringListAsType(node, flags) {
@@ -946,6 +987,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & 8388608 /* EvalFlags.ParsesStringLiteral */) === 0) {
             updatedFlags |= 524288 /* EvalFlags.NotParsed */;
         }
+        updatedFlags &= ~1073741824 /* EvalFlags.TypeFormArg */;
         if (node.d.annotation) {
             return getTypeOfExpression(node.d.annotation, updatedFlags);
         }
@@ -2260,13 +2302,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If this is a member name (within a class scope) and the member name
             // appears to be a constant, use the strict source type. If it's a member
             // variable that can be overridden by a child class, use the more general
-            // version by stripping off the literal.
+            // version by stripping off the literal and TypeForm.
             const scope = ScopeUtils.getScopeForNode(nameNode);
             if ((scope === null || scope === void 0 ? void 0 : scope.type) === 3 /* ScopeType.Class */) {
                 if (types_1.TypeBase.isInstance(destType) &&
                     !(0, symbolNameUtils_1.isConstantName)(nameValue) &&
                     !isFinalVariable(symbolWithScope.symbol)) {
-                    destType = stripLiteralValue(destType);
+                    destType = (0, typeUtils_1.stripTypeForm)(stripLiteralValue(destType));
                 }
             }
         }
@@ -2567,6 +2609,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // If conditionFilter is specified and the TypeVar is a constrained
     // TypeVar, only the conditions that match the filter will be included.
     function makeTopLevelTypeVarsConcrete(type, makeParamSpecsConcrete = false, conditionFilter) {
+        type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             var _a;
             if ((0, types_1.isParamSpec)(subtype)) {
@@ -2869,55 +2912,53 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function verifyRaiseExceptionType(node) {
         const baseExceptionType = getBuiltInType(node, 'BaseException');
-        if (node.d.typeExpression) {
-            const exceptionType = getTypeOfExpression(node.d.typeExpression).type;
-            // Validate that the argument of "raise" is an exception object or class.
-            // If it is a class, validate that the class's constructor accepts zero
-            // arguments.
-            if (exceptionType && baseExceptionType && (0, types_1.isInstantiableClass)(baseExceptionType)) {
-                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                (0, typeUtils_1.doForEachSubtype)(exceptionType, (subtype) => {
-                    const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
-                    if (!(0, types_1.isAnyOrUnknown)(concreteSubtype)) {
-                        if ((0, types_1.isInstantiableClass)(concreteSubtype) && concreteSubtype.priv.literalValue === undefined) {
-                            if (!(0, typeUtils_1.derivesFromClassRecursive)(concreteSubtype, baseExceptionType, 
-                            /* ignoreUnknown */ false)) {
-                                diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
-                                    type: printType(subtype),
-                                }));
-                            }
-                            else {
-                                let callResult;
-                                suppressDiagnostics(node.d.typeExpression, () => {
-                                    callResult = (0, constructors_1.validateConstructorArgs)(evaluatorInterface, node.d.typeExpression, [], concreteSubtype, 
-                                    /* skipUnknownArgCheck */ false, 
-                                    /* inferenceContext */ undefined);
-                                });
-                                if (callResult && callResult.argumentErrors) {
-                                    diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeNotInstantiable().format({
-                                        type: printType(subtype),
-                                    }));
-                                }
-                            }
-                        }
-                        else if ((0, types_1.isClassInstance)(concreteSubtype)) {
-                            if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(concreteSubtype), baseExceptionType, 
-                            /* ignoreUnknown */ false)) {
-                                diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
-                                    type: printType(subtype),
-                                }));
-                            }
-                        }
-                        else {
-                            diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
+        const exceptionType = getTypeOfExpression(node).type;
+        // Validate that the argument of "raise" is an exception object or class.
+        // If it is a class, validate that the class's constructor accepts zero
+        // arguments.
+        if (exceptionType && baseExceptionType && (0, types_1.isInstantiableClass)(baseExceptionType)) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            (0, typeUtils_1.doForEachSubtype)(exceptionType, (subtype) => {
+                const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
+                if ((0, types_1.isAnyOrUnknown)(concreteSubtype) || (0, types_1.isNever)(concreteSubtype) || (0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
+                    return;
+                }
+                if ((0, types_1.isInstantiableClass)(concreteSubtype) && concreteSubtype.priv.literalValue === undefined) {
+                    if (!(0, typeUtils_1.derivesFromClassRecursive)(concreteSubtype, baseExceptionType, /* ignoreUnknown */ false)) {
+                        diag.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
+                            type: printType(subtype),
+                        }));
+                    }
+                    else {
+                        let callResult;
+                        suppressDiagnostics(node, () => {
+                            callResult = (0, constructors_1.validateConstructorArgs)(evaluatorInterface, node, [], concreteSubtype, 
+                            /* skipUnknownArgCheck */ false, 
+                            /* inferenceContext */ undefined);
+                        });
+                        if (callResult && callResult.argumentErrors) {
+                            diag.addMessage(localize_1.LocMessage.exceptionTypeNotInstantiable().format({
                                 type: printType(subtype),
                             }));
                         }
                     }
-                });
-                if (!diagAddendum.isEmpty()) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedExceptionClass() + diagAddendum.getString(), node.d.typeExpression);
                 }
+                else if ((0, types_1.isClassInstance)(concreteSubtype)) {
+                    if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(concreteSubtype), baseExceptionType, 
+                    /* ignoreUnknown */ false)) {
+                        diag.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
+                            type: printType(subtype),
+                        }));
+                    }
+                }
+                else {
+                    diag.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
+                        type: printType(subtype),
+                    }));
+                }
+            });
+            if (!diag.isEmpty()) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedExceptionClass() + diag.getString(), node);
             }
         }
     }
@@ -3073,6 +3114,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                 type = validateSymbolIsTypeExpression(node, type, !!effectiveTypeInfo.includesVariableDecl);
             }
+            // Add TypeForm details if appropriate.
+            type = addTypeFormForSymbol(node, type, flags, !!effectiveTypeInfo.includesVariableDecl);
         }
         else {
             // Handle the special case of "reveal_type" and "reveal_locals".
@@ -3106,19 +3149,67 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type, isIncomplete };
     }
-    // Reports diagnostics if type isn't valid within a type expression.
-    function validateSymbolIsTypeExpression(node, type, includesVariableDecl) {
-        var _a;
-        // Verify that the name does not refer to a (non type alias) variable.
-        if (!includesVariableDecl || ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo)) {
+    function addTypeFormForSymbol(node, type, flags, includesVarDecl) {
+        var _a, _b;
+        if (!isTypeFormSupported(node)) {
             return type;
         }
-        if ((0, types_1.isTypeVar)(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
+        const isValid = isSymbolValidTypeExpression(type, includesVarDecl);
+        // If the type already has type information associated with it, don't replace.
+        if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+            // If the NoConvertSpecialForm flag is set, we are evaluating in
+            // the interior of a type expression, so variables are not allowed.
+            // Clear any existing type form type for this symbol in this case.
+            if ((flags & 33554432 /* EvalFlags.NoConvertSpecialForm */) !== 0 && !isValid) {
+                type = types_1.TypeBase.cloneWithTypeForm(type, undefined);
+            }
             return type;
         }
-        // Exempts class types that are created by calling
-        // NewType, NamedTuple, etc.
+        // If the symbol is not valid for a type expression (e.g. it's a variable),
+        // don't add TypeForm info.
+        if (!isValid) {
+            return type;
+        }
+        if ((0, types_1.isTypeVar)(type) && type.priv.scopeId && !type.shared.isSynthesized) {
+            if (!(0, types_1.isTypeVarTuple)(type) || !type.priv.isInUnion) {
+                const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
+                type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)((0, typeUtils_1.makeTypeVarsBound)(type, liveScopeIds)));
+            }
+        }
+        else if ((0, types_1.isInstantiableClass)(type) && !type.priv.includeSubclasses && !types_1.ClassType.isSpecialBuiltIn(type)) {
+            if (types_1.ClassType.isBuiltIn(type, 'Any')) {
+                type = types_1.TypeBase.cloneWithTypeForm(type, types_1.AnyType.create());
+            }
+            else {
+                type = types_1.TypeBase.cloneWithTypeForm(type, types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeWithDefaultTypeArgs)(type)));
+            }
+        }
+        if (((_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) && types_1.TypeBase.isInstantiable(type)) {
+            type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(specializeTypeAliasWithDefaults(type, /* errorNode */ undefined)));
+        }
+        return type;
+    }
+    function isSymbolValidTypeExpression(type, includesVarDecl) {
+        var _a;
+        // Verify that the name does not refer to a (non type alias) variable.
+        if (!includesVarDecl || ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo)) {
+            return true;
+        }
+        if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
+            return true;
+        }
+        if ((0, types_1.isTypeVar)(type) && !type.priv.scopeId) {
+            return true;
+        }
+        // Exempts class types that are created by calling NewType, NamedTuple, etc.
         if ((0, types_1.isClass)(type) && !type.priv.includeSubclasses && types_1.ClassType.isValidTypeAliasClass(type)) {
+            return true;
+        }
+        return false;
+    }
+    // Reports diagnostics if type isn't valid within a type expression.
+    function validateSymbolIsTypeExpression(node, type, includesVarDecl) {
+        if (isSymbolValidTypeExpression(type, includesVarDecl)) {
             return type;
         }
         // Disable for assignments in the typings.pyi file, since it defines special forms.
@@ -3133,7 +3224,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // evaluated in a value expression context, convert it from its special
     // meaning to its runtime value.
     function convertSpecialFormToRuntimeValue(type, flags) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const exemptFlags = 256 /* EvalFlags.TypeExpression */ | 128 /* EvalFlags.InstantiableType */ | 33554432 /* EvalFlags.NoConvertSpecialForm */;
         if ((flags & exemptFlags) !== 0) {
             return type;
@@ -3148,6 +3239,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!((_b = type.props) === null || _b === void 0 ? void 0 : _b.specialForm)) {
             return type;
         }
+        // If this is a type alias and we are not supposed to specialize it, return it as is.
+        if ((flags & 2 /* EvalFlags.NoSpecialize */) !== 0 && ((_c = type.props) === null || _c === void 0 ? void 0 : _c.typeAliasInfo)) {
+            // Special-case TypeAliasType which should be converted in this case.
+            if (!types_1.ClassType.isBuiltIn(type.props.specialForm, 'TypeAliasType')) {
+                return type;
+            }
+        }
+        if ((_d = type.props) === null || _d === void 0 ? void 0 : _d.typeForm) {
+            return types_1.TypeBase.cloneWithTypeForm(type.props.specialForm, type.props.typeForm);
+        }
         return type.props.specialForm;
     }
     // Handles the case where a variable or parameter is defined in an outer
@@ -3257,7 +3358,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnpackedTypeVarTuple)(type)) {
             type = types_1.TypeVarType.cloneForPacked(type);
         }
-        if ((flags & 1073741824 /* EvalFlags.EnforceClassTypeVarScope */) !== 0 && !enforceClassTypeVarScope(node, type)) {
+        if ((flags & -2147483648 /* EvalFlags.EnforceClassTypeVarScope */) !== 0 && !enforceClassTypeVarScope(node, type)) {
             return types_1.UnknownType.create();
         }
         return type;
@@ -3720,6 +3821,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                         type = validateSymbolIsTypeExpression(node, type, !!typeResult.includesVariableDecl);
                     }
+                    // Add TypeForm details if appropriate.
+                    type = addTypeFormForSymbol(node, type, flags, !!typeResult.includesVariableDecl);
                     if ((0, types_1.isTypeVar)(type)) {
                         type = validateTypeVarUsage(node, type, flags);
                     }
@@ -4083,9 +4186,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Check for an attempt to overwrite or delete an instance variable that is
             // read-only (e.g. in a named tuple).
-            if ((memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.isInstanceMember) &&
-                (0, types_1.isClass)(memberInfo.classType) &&
-                types_1.ClassType.isReadOnlyInstanceVariables(memberInfo.classType)) {
+            if ((memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.isInstanceMember) && (0, types_1.isClass)(memberInfo.classType) && memberInfo.isReadOnly) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.readOnlyAttribute().format({ name: memberName }));
                 isDescriptorError = true;
             }
@@ -4744,6 +4845,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const typeParams = aliasInfo.typeParams;
         let typeArgs = adjustTypeArgsForTypeVarTuple(getTypeArgs(node, flags), typeParams, node);
+        let reportedError = false;
         // PEP 612 says that if the class has only one type parameter consisting
         // of a ParamSpec, the list of arguments does not need to be enclosed in
         // a list. We'll handle that case specially here. Presumably this applies to
@@ -4770,6 +4872,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 expected: typeParams.length,
                 received: typeArgs.length,
             }), typeArgs[typeParams.length].node);
+            reportedError = true;
         }
         else if (typeArgs.length < minTypeArgCount) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooFew().format({
@@ -4777,6 +4880,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 expected: typeParams.length,
                 received: typeArgs.length,
             }), node.d.items[node.d.items.length - 1]);
+            reportedError = true;
         }
         // Handle the mypy_extensions.FlexibleAlias type specially.
         if ((0, types_1.isInstantiableClass)(baseType) &&
@@ -4832,11 +4936,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListExpected(), typeArgs[index].node);
+                    reportedError = true;
                 }
             }
             else {
                 if (index < typeArgs.length && typeArgs[index].typeList) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[index].node);
+                    reportedError = true;
                 }
                 let typeArgType;
                 if (index < typeArgs.length) {
@@ -4878,6 +4984,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         if (!diag.isEmpty()) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), node, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node);
+            reportedError = true;
         }
         const solutionSet = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints).getMainSolutionSet();
         const aliasTypeArgs = [];
@@ -4890,18 +4997,43 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             aliasTypeArgs.push(typeVarType);
         });
-        const type = types_1.TypeBase.cloneForTypeAlias(solveAndApplyConstraints(baseType, constraints), {
+        let type = types_1.TypeBase.cloneForTypeAlias(solveAndApplyConstraints(baseType, constraints), {
             ...aliasInfo,
             typeArgs: aliasTypeArgs,
         });
+        if (isTypeFormSupported(node)) {
+            type = types_1.TypeBase.cloneWithTypeForm(type, reportedError ? undefined : (0, typeUtils_1.convertToInstance)(type));
+        }
         return { type, node };
     }
     function getTypeOfIndexWithBaseType(node, baseTypeResult, usage, flags) {
+        var _a, _b, _c;
         // Handle the case where we're specializing a generic type alias.
         const typeAliasResult = createSpecializedTypeAlias(node, baseTypeResult.type, flags);
         if (typeAliasResult) {
             return typeAliasResult;
         }
+        // Handle the case where Never or NoReturn are being specialized.
+        if ((0, types_1.isNever)(baseTypeResult.type) && ((_a = baseTypeResult.type.props) === null || _a === void 0 ? void 0 : _a.specialForm)) {
+            // Swap in the special form type, which is the Never or NoReturn class.
+            baseTypeResult = { ...baseTypeResult, type: baseTypeResult.type.props.specialForm };
+        }
+        // Handle the case where a TypeAliasType symbol is being specialized
+        // in a value expression.
+        if ((0, types_1.isClassInstance)(baseTypeResult.type) &&
+            types_1.ClassType.isBuiltIn(baseTypeResult.type, 'TypeAliasType') &&
+            ((_b = baseTypeResult.type.props) === null || _b === void 0 ? void 0 : _b.typeForm)) {
+            const typeAliasInfo = (_c = baseTypeResult.type.props.typeForm.props) === null || _c === void 0 ? void 0 : _c.typeAliasInfo;
+            if (typeAliasInfo && typeAliasInfo.typeParams) {
+                const origTypeAlias = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.convertToInstantiable)(baseTypeResult.type.props.typeForm), { ...typeAliasInfo, typeArgs: undefined });
+                const typeFormType = createSpecializedTypeAlias(node, origTypeAlias, flags);
+                if (typeFormType) {
+                    return {
+                        type: types_1.TypeBase.cloneWithTypeForm(baseTypeResult.type, (0, typeUtils_1.convertToInstance)(typeFormType.type)),
+                    };
+                }
+            }
+        }
         if ((0, types_1.isTypeVar)(baseTypeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
             const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, {
@@ -5324,6 +5456,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeArgs(node, flags, options) {
         const typeArgs = [];
         let adjFlags = flags | 33554432 /* EvalFlags.NoConvertSpecialForm */;
+        adjFlags &= ~1073741824 /* EvalFlags.TypeFormArg */;
         const allowFinalClassVar = () => {
             // If the annotation is a variable within the body of a dataclass, a
             // Final is allowed with a ClassVar annotation. In all other cases,
@@ -5558,7 +5691,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const entryTypeResults = node.d.items.map((expr, index) => getTypeOfExpression(expr, flags | 268435456 /* EvalFlags.StripTupleLiterals */, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete)));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        const type = makeTupleObject(buildTupleTypesList(entryTypeResults, /* stripLiterals */ false));
         // Copy any expected type diag addenda for precision error reporting.
         let expectedTypeDiagAddendum;
         if (entryTypeResults.some((result) => result.expectedTypeDiagAddendum)) {
@@ -5569,11 +5701,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             });
         }
+        // If the tuple contains a very large number of entries, it's probably
+        // generated code. If we encounter type errors, don't bother building
+        // the full tuple type.
+        let type;
+        if (node.d.items.length > maxInferredTupleEntryCount && entryTypeResults.some((result) => result.typeErrors)) {
+            type = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]);
+        }
+        else {
+            type = makeTupleObject(buildTupleTypesList(entryTypeResults, /* stripLiterals */ false));
+        }
         return { type, expectedTypeDiagAddendum, isIncomplete };
     }
     function getTypeOfTupleInferred(node, flags) {
         const entryTypeResults = node.d.items.map((expr) => getTypeOfExpression(expr, flags | 268435456 /* EvalFlags.StripTupleLiterals */));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
+        // If the tuple contains a very large number of entries, it's probably
+        // generated code. Rather than taking the time to evaluate every entry,
+        // simply return an unknown type in this case.
+        if (node.d.items.length > maxInferredTupleEntryCount) {
+            return { type: makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }]) };
+        }
         const type = makeTupleObject(buildTupleTypesList(entryTypeResults, (flags & 268435456 /* EvalFlags.StripTupleLiterals */) !== 0));
         if (isIncomplete) {
             if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
@@ -5611,7 +5759,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 entryTypes.push({ type: types_1.UnknownType.create(/* isIncomplete */ true), isUnbounded: false });
             }
             else {
-                const entryType = stripLiterals ? stripLiteralValue(typeResult.type) : typeResult.type;
+                let entryType = convertSpecialFormToRuntimeValue(typeResult.type, 0 /* EvalFlags.None */);
+                entryType = stripLiterals ? (0, typeUtils_1.stripTypeForm)(stripLiteralValue(entryType)) : entryType;
                 entryTypes.push({ type: entryType, isUnbounded: !!typeResult.unpackedType });
             }
         }
@@ -5675,6 +5824,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Handle the "typing.assert_type" call.
                 typeResult = getTypeOfAssertType(node, inferenceContext);
             }
+            else if ((0, types_1.isClass)(baseTypeResult.type) && types_1.ClassType.isBuiltIn(baseTypeResult.type, 'TypeForm')) {
+                // Handle the "typing.TypeForm" call.
+                typeResult = getTypeOfTypeForm(node);
+            }
             else if ((0, types_1.isAnyOrUnknown)(baseTypeResult.type) &&
                 node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
                 node.d.leftExpr.d.value === 'reveal_locals') {
@@ -5778,7 +5931,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
+    function getTypeOfTypeForm(node) {
+        if (node.d.args.length !== 1 ||
+            node.d.args[0].d.argCategory !== 0 /* ArgCategory.Simple */ ||
+            node.d.args[0].d.name !== undefined) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeFormArgs(), node);
+            return { type: types_1.UnknownType.create() };
+        }
+        return getTypeOfArgExpectingType((0, typeUtils_1.convertNodeToArg)(node.d.args[0]), {
+            typeFormArg: isTypeFormSupported(node),
+            noNonTypeSpecialForms: true,
+            typeExpression: true,
+        });
+    }
     function getTypeOfAssertType(node, inferenceContext) {
+        var _a;
         if (node.d.args.length !== 2 ||
             node.d.args[0].d.argCategory !== 0 /* ArgCategory.Simple */ ||
             node.d.args[0].d.name !== undefined ||
@@ -5798,7 +5965,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // The spec is unclear on whether this is the correct behavior, but it seems to be
         // what mypy does -- and what various library authors expect.
         const arg0Type = stripTypeGuard(arg0TypeResult.type);
-        if (!(0, types_1.isTypeSame)(assertedType, arg0Type, { treatAnySameAsUnknown: true, ignorePseudoGeneric: true })) {
+        let assertSuccess = (0, types_1.isTypeSame)(assertedType, arg0Type, {
+            treatAnySameAsUnknown: true,
+            ignorePseudoGeneric: true,
+        });
+        // Handle TypeForm types specially.
+        if (!assertSuccess &&
+            ((_a = arg0Type.props) === null || _a === void 0 ? void 0 : _a.typeForm) &&
+            (0, types_1.isClassInstance)(assertedType) &&
+            types_1.ClassType.isBuiltIn(assertedType, 'TypeForm')) {
+            const typeFormType = assertedType.priv.typeArgs && assertedType.priv.typeArgs.length >= 1
+                ? assertedType.priv.typeArgs[0]
+                : types_1.UnknownType.create();
+            assertSuccess = (0, types_1.isTypeSame)(arg0Type.props.typeForm, typeFormType, {
+                treatAnySameAsUnknown: true,
+                ignorePseudoGeneric: true,
+            });
+        }
+        if (!assertSuccess) {
             const srcDestTypes = printSrcDestTypes(arg0TypeResult.type, assertedType, { expandTypeAlias: true });
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, localize_1.LocMessage.assertTypeTypeMismatch().format({
                 expected: srcDestTypes.destType,
@@ -5944,30 +6128,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const concreteTargetClassType = makeTopLevelTypeVarsConcrete(targetClassType);
         // Determine whether to further narrow the type.
+        let secondArgType;
         let bindToType;
         if (node.d.args.length > 1) {
-            const secondArgType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(node.d.args[1].d.valueExpr).type);
+            secondArgType = getTypeOfExpression(node.d.args[1].d.valueExpr).type;
+            const secondArgConcreteType = makeTopLevelTypeVarsConcrete(secondArgType);
             let reportError = false;
-            if ((0, types_1.isAnyOrUnknown)(secondArgType)) {
+            if ((0, types_1.isAnyOrUnknown)(secondArgConcreteType)) {
                 // Ignore unknown or any types.
             }
-            else if ((0, types_1.isClassInstance)(secondArgType)) {
+            else if ((0, types_1.isClassInstance)(secondArgConcreteType)) {
                 if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
-                    if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(secondArgType), concreteTargetClassType, 
+                    if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(secondArgConcreteType), concreteTargetClassType, 
                     /* ignoreUnknown */ true)) {
                         reportError = true;
                     }
                 }
-                bindToType = secondArgType;
+                bindToType = secondArgConcreteType;
             }
-            else if ((0, types_1.isInstantiableClass)(secondArgType)) {
+            else if ((0, types_1.isInstantiableClass)(secondArgConcreteType)) {
                 if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
                     if (!types_1.ClassType.isBuiltIn(concreteTargetClassType, 'type') &&
-                        !(0, typeUtils_1.derivesFromClassRecursive)(secondArgType, concreteTargetClassType, /* ignoreUnknown */ true)) {
+                        !(0, typeUtils_1.derivesFromClassRecursive)(secondArgConcreteType, concreteTargetClassType, 
+                        /* ignoreUnknown */ true)) {
                         reportError = true;
                     }
                 }
-                bindToType = secondArgType;
+                bindToType = secondArgConcreteType;
             }
             else {
                 reportError = true;
@@ -6069,10 +6256,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             let bindToSelfType;
             if (bindToType) {
-                if (node.d.args.length > 1) {
-                    // If this is a two-argument form of super(), use the
-                    // bindToType evaluated from the arguments.
-                    bindToSelfType = (0, typeUtils_1.convertToInstance)(bindToType);
+                if (secondArgType) {
+                    // If a TypeVar was passed as the second argument, use it
+                    // to derive the the self type.
+                    if ((0, types_1.isTypeVar)(secondArgType)) {
+                        bindToSelfType = (0, typeUtils_1.convertToInstance)(secondArgType);
+                    }
                 }
                 else {
                     // If this is a zero-argument form of super(), synthesize
@@ -7145,7 +7334,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchArgsToParams(errorNode, argList, typeResult, overloadIndex) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         const overload = typeResult.type;
         const paramDetails = (0, parameterUtils_1.getParamListDetails)(overload);
         const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(overload);
@@ -7562,9 +7751,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     else if ((0, types_1.isClassInstance)(argType) && types_1.ClassType.isTypedDictClass(argType)) {
                         // Handle the special case where it is a TypedDict and we know which
                         // keys are present.
-                        const typedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, argType);
+                        const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, argType);
                         const diag = new diagnostic_1.DiagnosticAddendum();
-                        typedDictEntries.knownItems.forEach((entry, name) => {
+                        tdEntries.knownItems.forEach((entry, name) => {
+                            var _a, _b;
                             const paramEntry = paramMap.get(name);
                             if (paramEntry && !paramEntry.isPositionalOnly) {
                                 if (paramEntry.argsReceived > 0) {
@@ -7583,7 +7773,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                             argCategory: 0 /* ArgCategory.Simple */,
                                             typeResult: { type: entry.valueType },
                                         },
-                                        errorNode: argList[argIndex].valueExpression || errorNode,
+                                        errorNode: (_a = argList[argIndex].valueExpression) !== null && _a !== void 0 ? _a : errorNode,
                                         paramName: name,
                                     });
                                 }
@@ -7598,7 +7788,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                         argCategory: 0 /* ArgCategory.Simple */,
                                         typeResult: { type: entry.valueType },
                                     },
-                                    errorNode: argList[argIndex].valueExpression || errorNode,
+                                    errorNode: (_b = argList[argIndex].valueExpression) !== null && _b !== void 0 ? _b : errorNode,
                                     paramName: name,
                                 });
                                 // Remember that this parameter has already received a value.
@@ -7618,6 +7808,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 }
                             }
                         });
+                        const extraItemsType = (_g = (_f = tdEntries.extraItems) === null || _f === void 0 ? void 0 : _f.valueType) !== null && _g !== void 0 ? _g : getObjectType();
+                        if (!(0, types_1.isNever)(extraItemsType)) {
+                            if (paramDetails.kwargsIndex !== undefined) {
+                                const kwargsParam = paramDetails.params[paramDetails.kwargsIndex];
+                                validateArgTypeParams.push({
+                                    paramCategory: 2 /* ParamCategory.KwargsDict */,
+                                    paramType: kwargsParam.declaredType,
+                                    requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(kwargsParam.declaredType),
+                                    argument: {
+                                        argCategory: 2 /* ArgCategory.UnpackedDictionary */,
+                                        typeResult: { type: extraItemsType },
+                                    },
+                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
+                                    paramName: kwargsParam.param.name,
+                                });
+                            }
+                        }
                         if (!diag.isEmpty()) {
                             if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
@@ -7724,7 +7931,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
-                                    errorNode: (_f = argList[argIndex].valueExpression) !== null && _f !== void 0 ? _f : errorNode,
+                                    errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
                                     paramName: paramNameValue,
                                 });
                                 trySetActive(argList[argIndex], paramDetails.params[paramInfoIndex].param);
@@ -7747,7 +7954,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
-                                    errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
+                                    errorNode: (_k = argList[argIndex].valueExpression) !== null && _k !== void 0 ? _k : errorNode,
                                     paramName: paramNameValue,
                                 });
                                 // Remember that this parameter has already received a value.
@@ -7798,7 +8005,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
                                     argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
-                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
+                                    errorNode: (_l = argList[argIndex].valueExpression) !== null && _l !== void 0 ? _l : errorNode,
                                 });
                             }
                         }
@@ -9208,6 +9415,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (node.d.constType === 26 /* KeywordType.None */) {
             if (noneTypeClass) {
                 type = (flags & 128 /* EvalFlags.InstantiableType */) !== 0 ? noneTypeClass : (0, typeUtils_1.convertToInstance)(noneTypeClass);
+                if (isTypeFormSupported(node)) {
+                    type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(type));
+                }
             }
         }
         else if (node.d.constType === 33 /* KeywordType.True */ ||
@@ -9472,9 +9682,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (keyValueResult.typeErrors) {
             typeErrors = true;
         }
-        // Strip any literal values.
-        const keyTypes = keyTypeResults.map((t) => stripLiteralValue(t.type));
-        const valueTypes = valueTypeResults.map((t) => stripLiteralValue(t.type));
+        // Strip any literal values and TypeForm types.
+        const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags)));
+        const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags)));
         keyType = keyTypes.length > 0 ? (0, types_1.combineTypes)(keyTypes) : fallbackType;
         // If the value type differs and we're not using "strict inference mode",
         // we need to back off because we can't properly represent the mappings
@@ -9825,6 +10035,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */);
             }
+            entryTypeResult.type = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(entryTypeResult.type, flags));
             if (entryTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -10359,8 +10570,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // a ParamSpec, a Concatenate, or a list of positional parameter types.
     // The second argument, if present, should specify the return type.
     function createCallableType(classType, typeArgs, errorNode) {
-        const functionType = types_1.FunctionType.createInstantiable(0 /* FunctionTypeFlags.None */);
+        let functionType = types_1.FunctionType.createInstantiable(0 /* FunctionTypeFlags.None */);
         let paramSpec;
+        let isValidTypeForm = true;
         types_1.TypeBase.setSpecialForm(functionType, types_1.ClassType.cloneAsInstance(classType));
         functionType.shared.declaredReturnType = types_1.UnknownType.create();
         functionType.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(errorNode);
@@ -10376,6 +10588,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (!reportedUnpackedError) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), entry.node);
                             reportedUnpackedError = true;
+                            isValidTypeForm = false;
                         }
                     }
                     sawUnpacked = true;
@@ -10437,6 +10650,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.callableFirstArg(), typeArgs[0].node);
+                    isValidTypeForm = false;
                 }
             }
             if (typeArgs.length > 1) {
@@ -10449,22 +10663,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.callableSecondArg(), errorNode);
                 functionType.shared.declaredReturnType = types_1.UnknownType.create();
+                isValidTypeForm = false;
             }
             if (typeArgs.length > 2) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.callableExtraArgs(), typeArgs[2].node);
+                isValidTypeForm = false;
             }
         }
         else {
             types_1.FunctionType.addDefaultParams(functionType, /* useUnknown */ true);
             functionType.shared.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
+            if (typeArgs && typeArgs.length === 0) {
+                isValidTypeForm = false;
+            }
         }
         if (paramSpec) {
             types_1.FunctionType.addParamSpecVariadics(functionType, (0, typeUtils_1.convertToInstance)(paramSpec));
         }
+        if (isTypeFormSupported(errorNode) && isValidTypeForm) {
+            functionType = types_1.TypeBase.cloneWithTypeForm(functionType, (0, typeUtils_1.convertToInstance)(functionType));
+        }
         return functionType;
     }
     // Creates an Optional[X] type.
     function createOptionalType(classType, errorNode, typeArgs, flags) {
+        var _a;
         if (!typeArgs) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
@@ -10487,6 +10710,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
             optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(unionTypeClass));
         }
+        if ((_a = typeArg0Type.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+            const typeFormType = (0, types_1.combineTypes)([
+                typeArg0Type.props.typeForm,
+                (0, typeUtils_1.convertToInstance)(noneTypeClass !== null && noneTypeClass !== void 0 ? noneTypeClass : types_1.UnknownType.create()),
+            ]);
+            optionalType = types_1.TypeBase.cloneWithTypeForm(optionalType, typeFormType);
+        }
         return optionalType;
     }
     function cloneBuiltinObjectWithLiteral(node, builtInName, value) {
@@ -10605,6 +10835,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnion)(result) && unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
             result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(unionTypeClass));
         }
+        if (isTypeFormSupported(node)) {
+            result = types_1.TypeBase.cloneWithTypeForm(result, (0, typeUtils_1.convertToInstance)(result));
+        }
         return result;
     }
     // Creates a ClassVar type.
@@ -10634,11 +10867,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return type;
     }
     function createTypeFormType(classType, errorNode, typeArgs) {
-        // If no type arguments are provided, the resulting type
-        // depends on whether we're evaluating a type annotation or
-        // we're in some other context.
-        if (!typeArgs) {
-            return classType;
+        if (!typeArgs || typeArgs.length === 0) {
+            return types_1.ClassType.specialize(classType, [types_1.UnknownType.create()]);
         }
         if (typeArgs.length > 1) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooMany().format({
@@ -10651,7 +10881,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const convertedTypeArgs = typeArgs.map((typeArg) => {
             return (0, typeUtils_1.convertToInstance)(validateTypeArg(typeArg) ? typeArg.type : types_1.UnknownType.create());
         });
-        const resultType = types_1.ClassType.specialize(classType, convertedTypeArgs);
+        let resultType = types_1.ClassType.specialize(classType, convertedTypeArgs);
+        if (isTypeFormSupported(errorNode)) {
+            resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
+        }
         return resultType;
     }
     // Creates a "TypeGuard" and "TypeIs" type.
@@ -10672,7 +10905,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const convertedTypeArgs = typeArgs.map((typeArg) => {
             return (0, typeUtils_1.convertToInstance)(validateTypeArg(typeArg) ? typeArg.type : types_1.UnknownType.create());
         });
-        const resultType = types_1.ClassType.specialize(classType, convertedTypeArgs);
+        let resultType = types_1.ClassType.specialize(classType, convertedTypeArgs);
+        if (isTypeFormSupported(errorNode)) {
+            resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
+        }
         return resultType;
     }
     function createSelfType(classType, errorNode, typeArgs, flags) {
@@ -10892,10 +11128,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
     function createAnnotatedType(classType, errorNode, typeArgs, flags) {
+        var _a;
         let type;
         const typeExprFlags = 256 /* EvalFlags.TypeExpression */ | 33554432 /* EvalFlags.NoConvertSpecialForm */;
         if ((flags & typeExprFlags) === 0) {
             type = types_1.ClassType.cloneAsInstance(classType);
+            if (typeArgs && typeArgs.length >= 1 && ((_a = typeArgs[0].type.props) === null || _a === void 0 ? void 0 : _a.typeForm)) {
+                type = types_1.TypeBase.cloneWithTypeForm(type, typeArgs[0].type.props.typeForm);
+            }
             return { type };
         }
         if (typeArgs && typeArgs.length > 0) {
@@ -11085,9 +11325,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Unpacks the index expression for a "Union[X, Y, Z]" type annotation.
     function createUnionType(classType, errorNode, typeArgs, flags) {
+        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         const types = [];
         let allowSingleTypeArg = false;
+        let isValidTypeForm = true;
         if (!typeArgs) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
@@ -11117,6 +11359,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionUnpackedTypeVarTuple(), errorNode);
                     typeArgType = types_1.UnknownType.create();
+                    isValidTypeForm = false;
                 }
             }
             types.push(typeArgType);
@@ -11126,11 +11369,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // since it is used to define NoReturn in typeshed stubs).
         if (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0])) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
+            isValidTypeForm = false;
         }
         let unionType = (0, types_1.combineTypes)(types, { skipElideRedundantLiterals: true });
         if (unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
             unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, types_1.ClassType.cloneAsInstance(unionTypeClass));
         }
+        if (!isValidTypeForm || types.some((t) => { var _a; return !((_a = t.props) === null || _a === void 0 ? void 0 : _a.typeForm); })) {
+            if ((_a = unionType.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+                unionType = types_1.TypeBase.cloneWithTypeForm(unionType, undefined);
+            }
+        }
+        else if (isTypeFormSupported(errorNode)) {
+            const typeFormType = (0, types_1.combineTypes)(types.map((t) => t.props.typeForm));
+            unionType = types_1.TypeBase.cloneWithTypeForm(unionType, typeFormType);
+        }
         return unionType;
     }
     // Creates a type that represents "Generic[T1, T2, ...]", used in the
@@ -11167,6 +11420,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
     function transformTypeForTypeAlias(type, name, errorNode, isPep695Syntax, isPep695TypeVarType, typeParams, typeParamNodes) {
+        var _a;
         if (!types_1.TypeBase.isInstantiable(type)) {
             return type;
         }
@@ -11248,6 +11502,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeAlias = types_1.TypeBase.cloneAsSpecialForm(typeAlias, types_1.ClassType.cloneAsInstance(typeAliasTypeClass));
             }
         }
+        // Delete the TypeForm info. The type alias serves as its own TypeForm info.
+        if ((_a = typeAlias.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+            typeAlias = types_1.TypeBase.cloneWithTypeForm(typeAlias, undefined);
+        }
         return typeAlias;
     }
     function createSpecialBuiltInClass(node, assignedName, aliasMapEntry) {
@@ -11375,15 +11633,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (aliasMapEntry) {
             const cachedType = readTypeCache(node, 0 /* EvalFlags.None */);
             if (cachedType) {
-                (0, debug_1.assert)((0, types_1.isInstantiableClass)(cachedType));
                 return cachedType;
             }
-            const specialType = createSpecialBuiltInClass(node, assignedName, aliasMapEntry);
+            let specialType = createSpecialBuiltInClass(node, assignedName, aliasMapEntry);
             // Handle 'LiteralString' specially because we want it to act as
             // though it derives from 'str'.
             if (assignedName === 'LiteralString') {
                 specialType.shared.baseClasses.push(strClass !== null && strClass !== void 0 ? strClass : types_1.AnyType.create());
                 (0, typeUtils_1.computeMroLinearization)(specialType);
+                if (isTypeFormSupported(node)) {
+                    specialType = types_1.TypeBase.cloneWithTypeForm(specialType, (0, typeUtils_1.convertToInstance)(specialType));
+                }
+            }
+            // Handle 'Never' and 'NoReturn' specially.
+            if (assignedName === 'Never' || assignedName === 'NoReturn') {
+                specialType = types_1.TypeBase.cloneAsSpecialForm(assignedName === 'Never' ? types_1.NeverType.createNever() : types_1.NeverType.createNoReturn(), specialType);
+                if (isTypeFormSupported(node)) {
+                    specialType = types_1.TypeBase.cloneWithTypeForm(specialType, (0, typeUtils_1.convertToInstance)(specialType));
+                }
             }
             writeTypeCache(node, { type: specialType }, 0 /* EvalFlags.None */);
             return specialType;
@@ -11475,7 +11742,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         64 /* EvalFlags.NoTypeVarTuple */ |
                         131072 /* EvalFlags.NoClassVar */;
                 typeAliasNameNode = node.d.leftExpr.d.valueExpr;
-                if (!isLegalTypeAliasExpressionForm(node.d.rightExpr)) {
+                if (!isLegalTypeAliasExpressionForm(node.d.rightExpr, /* allowStrLiteral */ true)) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAliasIllegalExpressionForm(), node.d.rightExpr);
                 }
             }
@@ -11783,6 +12050,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isAny)(argType) && ((_b = argType.props) === null || _b === void 0 ? void 0 : _b.specialForm)) {
                         argType = types_1.AnyType.create();
                     }
+                    argType = (0, typeUtils_1.stripTypeFormRecursive)(argType);
                     if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
                         if ((0, typeUtils_1.isMetaclassInstance)(argType)) {
                             (0, debug_1.assert)((0, types_1.isClassInstance)(argType));
@@ -11819,7 +12087,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_6)) {
                                 if (types_1.ClassType.isBuiltIn(argType, 'NamedTuple')) {
                                     isNamedTupleSubclass = true;
-                                    classType.shared.flags |= 524288 /* ClassTypeFlags.ReadOnlyInstanceVariables */;
                                 }
                             }
                             // If the class directly derives from TypedDict or from a class that is
@@ -12097,7 +12364,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if ((0, enums_1.isEnumMetaclass)(metaclassType)) {
                             classType.shared.flags |= 65536 /* ClassTypeFlags.EnumClass */;
                         }
-                        if (types_1.ClassType.isBuiltIn(metaclassType, 'ABCMeta')) {
+                        if ((0, typeUtils_1.derivesFromStdlibClass)(metaclassType, 'ABCMeta')) {
                             classType.shared.flags |= 64 /* ClassTypeFlags.SupportsAbstractMethods */;
                         }
                     }
@@ -13103,7 +13370,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 skipInference = true;
             }
             if (!skipInference) {
-                inferredParamType = stripLiteralValue(defaultValueType);
+                inferredParamType = convertSpecialFormToRuntimeValue(defaultValueType, 0 /* EvalFlags.None */);
+                inferredParamType = (0, typeUtils_1.stripTypeForm)(inferredParamType);
+                inferredParamType = stripLiteralValue(inferredParamType);
             }
         }
         if (inferredParamType) {
@@ -13276,6 +13545,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                             }
                                             return subtype;
                                         });
+                                        // Do not retain TypeForm types in inferred return types.
+                                        returnType = (0, typeUtils_1.stripTypeForm)(returnType);
                                         inferredReturnTypes.push(returnType);
                                     }
                                     else {
@@ -13384,10 +13655,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return false;
         }
         for (const raiseStatement of functionDecl.raiseStatements) {
-            if (!raiseStatement.d.typeExpression || raiseStatement.d.valueExpression) {
+            if (!raiseStatement.d.expr || raiseStatement.d.fromExpr) {
                 return false;
             }
-            const raiseType = getTypeOfExpression(raiseStatement.d.typeExpression).type;
+            const raiseType = getTypeOfExpression(raiseStatement.d.expr).type;
             const classType = (0, types_1.isInstantiableClass)(raiseType)
                 ? raiseType
                 : (0, types_1.isClassInstance)(raiseType)
@@ -14314,6 +14585,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Returns the specialized type and a boolean indicating whether
     // the type indicates a class type (true) or an object type (false).
     function createSpecializedClassType(classType, typeArgs, flags, errorNode) {
+        let isValidTypeForm = true;
         // Handle the special-case classes that are not defined
         // in the type stubs.
         if (types_1.ClassType.isSpecialBuiltIn(classType)) {
@@ -14327,7 +14599,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (typeArgs && typeArgs.length > 0) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsExpectingNone().format({ name: aliasedName }), typeArgs[0].node);
                     }
-                    const resultType = aliasedName === 'Never' ? types_1.NeverType.createNever() : types_1.NeverType.createNoReturn();
+                    let resultType = aliasedName === 'Never' ? types_1.NeverType.createNever() : types_1.NeverType.createNoReturn();
+                    resultType = types_1.TypeBase.cloneAsSpecialForm(resultType, classType);
+                    if (isTypeFormSupported(errorNode)) {
+                        resultType = types_1.TypeBase.cloneWithTypeForm(resultType, (0, typeUtils_1.convertToInstance)(resultType));
+                    }
                     return { type: resultType };
                 }
                 case 'Optional': {
@@ -14340,6 +14616,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isInstantiableClass)(typeType)) {
                         typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
                     }
+                    if (isTypeFormSupported(errorNode)) {
+                        typeType = types_1.TypeBase.cloneWithTypeForm(typeType, (0, typeUtils_1.convertToInstance)(typeType));
+                    }
                     return { type: typeType };
                 }
                 case 'ClassVar': {
@@ -14364,12 +14643,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typedDictNotAllowed(), errorNode);
                     }
+                    isValidTypeForm = false;
                     break;
                 }
                 case 'Literal': {
                     if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNotAllowed(), errorNode);
                     }
+                    isValidTypeForm = false;
                     break;
                 }
                 case 'Tuple': {
@@ -14442,16 +14723,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isInstantiableClass)(typeType)) {
                         typeType = (0, typeUtils_1.explodeGenericClass)(typeType);
                     }
+                    if (isTypeFormSupported(errorNode)) {
+                        typeType = types_1.TypeBase.cloneWithTypeForm(typeType, (0, typeUtils_1.convertToInstance)(typeType));
+                    }
                     return { type: typeType };
                 }
             }
             // Handle "tuple" specially, since it needs to act like "Tuple"
             // in Python 3.9 and newer.
             if ((0, typeUtils_1.isTupleClass)(classType)) {
-                const specializedClass = createSpecialType(classType, typeArgs, 
+                let specializedClass = createSpecialType(classType, typeArgs, 
                 /* paramLimit */ undefined, 
                 /* allowParamSpec */ undefined, 
                 /* isSpecialForm */ false);
+                if (isTypeFormSupported(errorNode)) {
+                    specializedClass = types_1.TypeBase.cloneWithTypeForm(specializedClass, (0, typeUtils_1.convertToInstance)(specializedClass));
+                }
                 return { type: specializedClass };
             }
         }
@@ -14473,11 +14760,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (typeArgCount > typeParams.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     if (typeParams.length === 0) {
+                        isValidTypeForm = false;
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
                             name: classType.priv.aliasName || classType.shared.name,
                         }), typeArgs[typeParams.length].node);
                     }
                     else if (typeParams.length !== 1 || !(0, types_1.isParamSpec)(typeParams[0])) {
+                        isValidTypeForm = false;
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
                             name: classType.priv.aliasName || classType.shared.name,
                             expected: typeParams.length,
@@ -14488,6 +14777,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else if (typeArgCount < minTypeArgCount) {
+                isValidTypeForm = false;
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooFew().format({
                     name: classType.priv.aliasName || classType.shared.name,
                     expected: minTypeArgCount,
@@ -14495,6 +14785,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }), typeArgs.length > 0 ? typeArgs[0].node.parent : errorNode);
             }
             typeArgs.forEach((typeArg, index) => {
+                var _a;
+                if (!((_a = typeArg.type.props) === null || _a === void 0 ? void 0 : _a.typeForm)) {
+                    isValidTypeForm = false;
+                }
                 if (index === variadicTypeParamIndex) {
                     // The types that make up the tuple that maps to the
                     // TypeVarTuple have already been validated when the tuple
@@ -14503,16 +14797,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return;
                     }
                     if ((0, types_1.isTypeVarTuple)(typeArg.type)) {
-                        validateTypeVarTupleIsUnpacked(typeArg.type, typeArg.node);
+                        if (!validateTypeVarTupleIsUnpacked(typeArg.type, typeArg.node)) {
+                            isValidTypeForm = false;
+                        }
                         return;
                     }
                 }
                 const typeParam = index < typeParams.length ? typeParams[index] : undefined;
                 const isParamSpecTarget = typeParam && (0, types_1.isParamSpec)(typeParam);
-                validateTypeArg(typeArg, {
+                if (!validateTypeArg(typeArg, {
                     allowParamSpec: true,
                     allowTypeArgList: isParamSpecTarget,
-                });
+                })) {
+                    isValidTypeForm = false;
+                }
             });
         }
         // Handle ParamSpec arguments and fill in any missing type arguments with Unknown.
@@ -14542,10 +14840,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else if (typeArgs.length > 1) {
                 const paramSpecTypeArg = typeArgs.find((typeArg) => (0, types_1.isParamSpec)(typeArg.type));
                 if (paramSpecTypeArg) {
+                    isValidTypeForm = false;
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), paramSpecTypeArg.node);
                 }
                 const listTypeArg = typeArgs.find((typeArg) => !!typeArg.typeList);
                 if (listTypeArg) {
+                    isValidTypeForm = false;
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), listTypeArg.node);
                 }
             }
@@ -14633,6 +14933,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Avoid emitting this error for a partially-constructed class.
                     if (!(0, types_1.isClassInstance)(typeArgType) || !types_1.ClassType.isPartiallyEvaluated(typeArgType)) {
                         (0, debug_1.assert)(typeArgs !== undefined);
+                        isValidTypeForm = false;
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeVarAssignmentMismatch().format({
                             type: printType(typeArgType),
                             name: types_1.TypeVarType.getReadableName(typeParams[index]),
@@ -14648,7 +14949,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (typeArgs && classType.shared.typeParams.length === 0 && types_1.ClassType.isPartiallyEvaluated(classType)) {
             typeArgTypes = typeArgs.map((t) => (0, typeUtils_1.convertToInstance)(t.type));
         }
-        const specializedClass = types_1.ClassType.specialize(classType, typeArgTypes, typeArgs !== undefined);
+        let specializedClass = types_1.ClassType.specialize(classType, typeArgTypes, typeArgs !== undefined);
+        if (isTypeFormSupported(errorNode)) {
+            specializedClass = types_1.TypeBase.cloneWithTypeForm(specializedClass, isValidTypeForm ? (0, typeUtils_1.convertToInstance)(specializedClass) : undefined);
+        }
         return { type: specializedClass };
     }
     function getTypeOfArg(arg, inferenceContext) {
@@ -14687,7 +14991,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             flags |= 8192 /* EvalFlags.TypeVarGetsCurScope */;
         }
         if (options === null || options === void 0 ? void 0 : options.enforceClassTypeVarScope) {
-            flags |= 1073741824 /* EvalFlags.EnforceClassTypeVarScope */;
+            flags |= -2147483648 /* EvalFlags.EnforceClassTypeVarScope */;
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(fileInfo) || (options === null || options === void 0 ? void 0 : options.forwardRefs)) {
@@ -14732,6 +15036,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (options === null || options === void 0 ? void 0 : options.notParsed) {
             flags |= 524288 /* EvalFlags.NotParsed */;
         }
+        if (options === null || options === void 0 ? void 0 : options.typeFormArg) {
+            flags |= 1073741824 /* EvalFlags.TypeFormArg */;
+        }
         return getTypeOfExpression(node, flags);
     }
     function getBuiltInType(node, name) {
@@ -14988,7 +15295,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // In general, string nodes don't have any declarations associated with them, but
     // we need to handle the special case of string literals used as keys within a
     // dictionary expression where those keys are associated with a known TypedDict.
-    function getDeclarationsForStringNode(node) {
+    function getDeclInfoForStringNode(node) {
         var _a;
         const declarations = [];
         const expectedType = (_a = getExpectedType(node)) === null || _a === void 0 ? void 0 : _a.type;
@@ -15010,7 +15317,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             });
         }
-        return declarations.length === 0 ? undefined : declarations;
+        return declarations.length === 0 ? undefined : { decls: declarations, synthesizedTypes: [] };
     }
     function getAliasFromImport(node) {
         if (node.parent &&
@@ -15021,12 +15328,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
-    function getDeclarationsForNameNode(node, skipUnreachableCode = true) {
+    function getDeclInfoForNameNode(node, skipUnreachableCode = true) {
         var _a, _b, _c;
         if (skipUnreachableCode && AnalyzerNodeInfo.isCodeUnreachable(node)) {
             return undefined;
         }
         const declarations = [];
+        const synthesizedTypes = [];
         // If the node is part of a "from X import Y as Z" statement and the node
         // is the "Y" (non-aliased) name, we need to look up the alias symbol
         // since the non-aliased name is not in the symbol table.
@@ -15096,7 +15404,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             (0, collectionUtils_1.appendArray)(declarations, typedDecls);
                         }
                         else {
-                            (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
+                            const synthesizedType = symbol.getSynthesizedType();
+                            if (synthesizedType) {
+                                synthesizedTypes.push(synthesizedType);
+                            }
+                            else {
+                                (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
+                            }
                         }
                     }
                 });
@@ -15178,7 +15492,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 (0, collectionUtils_1.appendArray)(declarations, symbolWithScope.symbol.getDeclarations());
             }
         }
-        return declarations;
+        return { decls: declarations, synthesizedTypes };
     }
     function getTypeForDeclaration(declaration) {
         var _a, _b;
@@ -15724,6 +16038,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return true;
                 }
             }
+            if (decl.type === 2 /* DeclarationType.Param */) {
+                return true;
+            }
             return false;
         });
     }
@@ -15880,9 +16197,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 isConstant = true;
                             }
                             // If the symbol is constant, we can retain the literal
-                            // value. Otherwise, strip literal values to widen the type.
+                            // value and TypeForm types. Otherwise, strip literal values
+                            // and TypeForm types to widen.
                             if (types_1.TypeBase.isInstance(type) && !isConstant && !isExplicitTypeAliasDeclaration(decl)) {
-                                type = stripLiteralValue(type);
+                                type = (0, typeUtils_1.stripTypeForm)(stripLiteralValue(type));
                             }
                         }
                         typesToCombine.push(type);
@@ -16240,7 +16558,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             paramType = types_1.UnknownType.create();
                         }
                         if (stripLiteralArgTypes) {
-                            paramType = stripLiteralValue(paramType);
+                            paramType = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(paramType), 0 /* EvalFlags.None */));
                         }
                         paramTypes.push(paramType);
                         writeTypeCache(param.d.name, { type: paramType }, 0 /* EvalFlags.None */);
@@ -16520,8 +16838,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     let flags = 0 /* AssignTypeFlags.Default */;
                     if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ &&
                         !isFinalVariableDeclaration(primaryDecl) &&
-                        !types_1.ClassType.isReadOnlyInstanceVariables(destType) &&
-                        !types_1.ClassType.isDataClassFrozen(destType)) {
+                        !(0, typeUtils_1.isMemberReadOnly)(destType, name)) {
                         // Class and instance variables that are mutable need to
                         // enforce invariance. We will exempt variables that are
                         // private or protected, since these are presumably
@@ -16772,7 +17089,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // in the dest type is not in the type map already, it is assigned a type
     // and added to the map.
     function assignType(destType, srcType, diag, constraints, flags = 0 /* AssignTypeFlags.Default */, recursionCount = 0) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         // Handle the case where the dest and src types are the same object.
         // We can normally shortcut this and say that they are compatible,
         // but if the type includes TypeVars, we need to go through
@@ -16793,7 +17110,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if (!isSpecialFormExempt) {
-                srcType = specialForm;
+                if (((_b = srcType.props) === null || _b === void 0 ? void 0 : _b.typeForm) && !((_c = specialForm.props) === null || _c === void 0 ? void 0 : _c.typeForm)) {
+                    srcType = types_1.TypeBase.cloneWithTypeForm(specialForm, srcType.props.typeForm);
+                }
+                else {
+                    srcType = specialForm;
+                }
             }
         }
         if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -16806,8 +17128,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             destType.shared.recursiveAlias &&
             (0, types_1.isTypeVar)(srcType) &&
             srcType.shared.recursiveAlias) {
-            const destAliasInfo = (_b = destType.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
-            const srcAliasInfo = (_c = srcType.props) === null || _c === void 0 ? void 0 : _c.typeAliasInfo;
+            const destAliasInfo = (_d = destType.props) === null || _d === void 0 ? void 0 : _d.typeAliasInfo;
+            const srcAliasInfo = (_e = srcType.props) === null || _e === void 0 ? void 0 : _e.typeAliasInfo;
             // Do the source and dest refer to the same recursive type alias?
             if ((destAliasInfo === null || destAliasInfo === void 0 ? void 0 : destAliasInfo.typeArgs) &&
                 (srcAliasInfo === null || srcAliasInfo === void 0 ? void 0 : srcAliasInfo.typeArgs) &&
@@ -16857,8 +17179,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnbound)(destType) || (0, types_1.isUnbound)(srcType)) {
             return true;
         }
-        // Before performing any other checks, see if the dest type is a
-        // TypeVar that we are attempting to match.
+        // Handle TypeForm assignments.
+        if (assignToTypeFormType(destType, srcType, constraints, flags, recursionCount)) {
+            return true;
+        }
         if ((0, types_1.isTypeVar)(destType)) {
             if ((0, typeUtils_1.isTypeVarSame)(destType, srcType)) {
                 return true;
@@ -16873,7 +17197,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // and the bound TypeVar matches the condition, the types are compatible.
             const destTypeVar = destType;
             if (types_1.TypeBase.isInstantiable(destType) === types_1.TypeBase.isInstantiable(srcType) &&
-                ((_d = srcType.props) === null || _d === void 0 ? void 0 : _d.condition) &&
+                ((_f = srcType.props) === null || _f === void 0 ? void 0 : _f.condition) &&
                 srcType.props.condition.some((cond) => {
                     return (!types_1.TypeVarType.hasConstraints(cond.typeVar) &&
                         cond.typeVar.priv.nameWithScope === destTypeVar.priv.nameWithScope);
@@ -16974,7 +17298,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isAnyOrUnknown)(destType)) {
             return true;
         }
-        if ((0, types_1.isAnyOrUnknown)(srcType) && !((_e = srcType.props) === null || _e === void 0 ? void 0 : _e.specialForm)) {
+        if ((0, types_1.isAnyOrUnknown)(srcType) && !((_g = srcType.props) === null || _g === void 0 ? void 0 : _g.specialForm)) {
             if (constraints) {
                 // If it's an ellipsis type, convert it to a regular "Any"
                 // type. These are functionally equivalent, but "Any" looks
@@ -17058,12 +17382,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return false;
                     }
                 }
-                if (types_1.ClassType.isBuiltIn(destType, 'type') && ((_g = (_f = srcType.props) === null || _f === void 0 ? void 0 : _f.instantiableDepth) !== null && _g !== void 0 ? _g : 0) > 0) {
+                if (types_1.ClassType.isBuiltIn(destType, 'type') && ((_j = (_h = srcType.props) === null || _h === void 0 ? void 0 : _h.instantiableDepth) !== null && _j !== void 0 ? _j : 0) > 0) {
                     return true;
                 }
                 if (isSpecialFormClass(expandedSrcType, flags)) {
-                    if ((_h = destType.props) === null || _h === void 0 ? void 0 : _h.specialForm) {
-                        return assignType(destType.props.specialForm, expandedSrcType, diag, constraints, flags, recursionCount);
+                    // Special form classes are compatible only with other special form
+                    // classes, not with 'object' or 'type'.
+                    const destSpecialForm = (_l = (_k = destType.props) === null || _k === void 0 ? void 0 : _k.specialForm) !== null && _l !== void 0 ? _l : destType;
+                    if (isSpecialFormClass(destSpecialForm, flags)) {
+                        return assignType(destSpecialForm, expandedSrcType, diag, constraints, flags, recursionCount);
                     }
                 }
                 else if (assignClass(destType, expandedSrcType, diag, constraints, flags, recursionCount, 
@@ -17197,7 +17524,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
             }
-            else if ((0, types_1.isAnyOrUnknown)(concreteSrcType) && !((_j = concreteSrcType.props) === null || _j === void 0 ? void 0 : _j.specialForm)) {
+            else if ((0, types_1.isAnyOrUnknown)(concreteSrcType) && !((_m = concreteSrcType.props) === null || _m === void 0 ? void 0 : _m.specialForm)) {
                 return (flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0;
             }
             else if ((0, types_1.isUnion)(concreteSrcType)) {
@@ -17325,6 +17652,45 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
         return false;
     }
+    // If the destination type is an explicit TypeForm type, see if the source
+    // type has an implicit TypeForm type that can be assigned to it. Also see
+    // of the source is a type[T] type that is assignable.
+    function assignToTypeFormType(destType, srcType, constraints, flags, recursionCount) {
+        var _a, _b;
+        if (!(0, types_1.isClassInstance)(destType) || !types_1.ClassType.isBuiltIn(destType, 'TypeForm')) {
+            return false;
+        }
+        const destTypeFormType = destType.priv.typeArgs && destType.priv.typeArgs.length > 0
+            ? destType.priv.typeArgs[0]
+            : types_1.UnknownType.create();
+        let srcTypeFormType;
+        // Is the source is a TypeForm type?
+        if ((_a = srcType.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+            srcTypeFormType = srcType.props.typeForm;
+        }
+        else if ((0, types_1.isClass)(srcType)) {
+            if (types_1.TypeBase.isInstantiable(srcType)) {
+                if (!types_1.ClassType.isSpecialBuiltIn(srcType)) {
+                    srcTypeFormType = types_1.ClassType.cloneAsInstance(srcType);
+                }
+            }
+            else if (types_1.ClassType.isBuiltIn(srcType, 'type')) {
+                srcTypeFormType =
+                    ((_b = srcType.priv.typeArgs) === null || _b === void 0 ? void 0 : _b.length) && srcType.priv.typeArgs.length > 0
+                        ? srcType.priv.typeArgs[0]
+                        : types_1.UnknownType.create();
+            }
+        }
+        else if ((0, types_1.isTypeVar)(srcType) && types_1.TypeBase.isInstantiable(srcType)) {
+            if (!(0, types_1.isTypeVarTuple)(srcType) || !srcType.priv.isInUnion) {
+                srcTypeFormType = (0, typeUtils_1.convertToInstance)(srcType);
+            }
+        }
+        if (!srcTypeFormType) {
+            return false;
+        }
+        return assignType(destTypeFormType, srcTypeFormType, /* diag */ undefined, constraints, flags, recursionCount);
+    }
     function assignFromUnionType(destType, srcType, diag, constraints, flags, recursionCount) {
         // Start by checking for an exact match. This is needed to handle unions
         // that contain recursive type aliases.
@@ -17464,8 +17830,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else {
                     // Try to assign a union of the remaining source types to
-                    // the first destination TypeVar.
-                    if (!assignType(isContra ? (0, types_1.combineTypes)(remainingDestSubtypes) : remainingDestSubtypes[0], isContra ? remainingSrcSubtypes[0] : (0, types_1.combineTypes)(remainingSrcSubtypes), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
+                    // the first destination TypeVar. If this is a contravariant
+                    // context, use the full dest type rather than the remaining
+                    // dest subtypes to keep the lower bound as wide as possible.
+                    if (!assignType(isContra ? destType : remainingDestSubtypes[0], isContra ? remainingSrcSubtypes[0] : (0, types_1.combineTypes)(remainingSrcSubtypes), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                         canUseFastPath = false;
                     }
                 }
@@ -17644,7 +18012,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // in case the destType is a union with hundreds of literals.
                 if ((0, types_1.isClassInstance)(srcType) &&
                     (0, typeUtils_1.isLiteralType)(srcType) &&
-                    types_1.UnionType.containsType(destType, srcType, /* exclusionSet */ undefined, recursionCount)) {
+                    types_1.UnionType.containsType(destType, srcType, 
+                    /* options */ undefined, 
+                    /* exclusionSet */ undefined, recursionCount)) {
                     return true;
                 }
                 (0, typeUtils_1.doForEachSubtype)(destType, (subtype) => {
@@ -18321,9 +18691,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // is the first remaining param.
                     }
                     else {
-                        remainingParams.push(types_1.FunctionParam.create(p.category, types_1.FunctionType.getParamType(effectiveSrcType, index), p.flags, p.name, types_1.FunctionType.getParamDefaultType(effectiveSrcType, index)
-                            ? types_1.AnyType.create(/* isEllipsis */ true)
-                            : undefined, p.defaultExpr));
+                        remainingParams.push(types_1.FunctionParam.create(p.category, types_1.FunctionType.getParamType(effectiveSrcType, index), p.flags, p.name, types_1.FunctionType.getParamDefaultType(effectiveSrcType, index), p.defaultExpr));
                     }
                 });
                 // If there are remaining parameters and the source and dest do not contain
@@ -19183,9 +19551,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Perform a sanity check on the RHS expression. Some expression
         // forms should never be considered legitimate for type aliases.
-        return isLegalTypeAliasExpressionForm(decl.node.parent.d.rightExpr);
+        return isLegalTypeAliasExpressionForm(decl.node.parent.d.rightExpr, /* allowStrLiteral */ false);
     }
-    function isLegalTypeAliasExpressionForm(node) {
+    function isLegalTypeAliasExpressionForm(node, allowStrLiteral) {
         switch (node.nodeType) {
             case 0 /* ParseNodeType.Error */:
             case 55 /* ParseNodeType.UnaryOperation */:
@@ -19206,14 +19574,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             case 34 /* ParseNodeType.List */:
             case 45 /* ParseNodeType.Set */:
                 return false;
+            case 48 /* ParseNodeType.StringList */:
+            case 49 /* ParseNodeType.String */:
+                return allowStrLiteral;
+            case 14 /* ParseNodeType.Constant */:
+                return node.d.constType === 26 /* KeywordType.None */;
             case 7 /* ParseNodeType.BinaryOperation */:
                 return (node.d.operator === 6 /* OperatorType.BitwiseOr */ &&
-                    isLegalTypeAliasExpressionForm(node.d.leftExpr) &&
-                    isLegalTypeAliasExpressionForm(node.d.rightExpr));
+                    isLegalTypeAliasExpressionForm(node.d.leftExpr, /* allowStrLiteral */ true) &&
+                    isLegalTypeAliasExpressionForm(node.d.rightExpr, /* allowStrLiteral */ true));
             case 27 /* ParseNodeType.Index */:
-                return isLegalTypeAliasExpressionForm(node.d.leftExpr);
+                return isLegalTypeAliasExpressionForm(node.d.leftExpr, allowStrLiteral);
             case 35 /* ParseNodeType.MemberAccess */:
-                return isLegalTypeAliasExpressionForm(node.d.leftExpr);
+                return isLegalTypeAliasExpressionForm(node.d.leftExpr, allowStrLiteral);
         }
         return true;
     }
@@ -19292,6 +19665,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { sourceType: simpleSrcType, destType: simpleDestType };
     }
+    function isTypeFormSupported(node) {
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        // For now, enable only if enableExperimentalFeatures is true.
+        return fileInfo.diagnosticRuleSet.enableExperimentalFeatures;
+    }
     function printType(type, options) {
         let flags = evaluatorOptions.printTypeFlags;
         if (options === null || options === void 0 ? void 0 : options.expandTypeAlias) {
@@ -19345,12 +19723,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const parseResults = parser.parseTextExpression(dummyFileContents, valueOffset, textValue.length, parseOptions, 0 /* ParseTextMode.Expression */, 
         /* initialParenDepth */ undefined, fileInfo.typingSymbolAliases);
         if (parseResults.parseTree) {
-            if (reportErrors) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                parseResults.diagnostics.forEach((diag) => {
-                    fileInfo.diagnosticSink.addDiagnosticWithTextRange('error', diag.message, node);
-                });
+            // If there are errors but we are not reporting them, return
+            // undefined to indicate that the parse failed.
+            if (!reportErrors && parseResults.diagnostics.length > 0) {
+                return undefined;
             }
+            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            parseResults.diagnostics.forEach((diag) => {
+                fileInfo.diagnosticSink.addDiagnosticWithTextRange('error', diag.message, node);
+            });
             parseResults.parseTree.parent = node;
             // Optionally add the new subtree to the parse tree so it can
             // participate in language server operations like find and replace.
@@ -19420,8 +19801,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         isAsymmetricAccessorAssignment,
         suppressDiagnostics,
         isSpecialFormClass,
-        getDeclarationsForStringNode,
-        getDeclarationsForNameNode,
+        getDeclInfoForStringNode,
+        getDeclInfoForNameNode,
         getTypeForDeclaration,
         resolveAliasDeclaration,
         resolveAliasDeclarationWithInfo,