@zzzen/pyright-internal 1.2.0-dev.20240825 → 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,92 +901,132 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return typeResult;
     }
     function getTypeOfStringList(node, flags) {
+        var _a;
         let typeResult;
-        if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0) {
-            let updatedFlags = flags | 4 /* EvalFlags.ForwardRefs */ | 128 /* EvalFlags.InstantiableType */;
-            // In most cases, annotations within a string are not parsed by the interpreter.
-            // There are a few exceptions (e.g. the "bound" value for a TypeVar constructor).
-            if ((flags & 8388608 /* EvalFlags.ParsesStringLiteral */) === 0) {
-                updatedFlags |= 524288 /* EvalFlags.NotParsed */;
-            }
-            if (node.d.annotation) {
-                typeResult = getTypeOfExpression(node.d.annotation, updatedFlags);
-            }
-            else if (node.d.strings.length === 1) {
-                const tokenFlags = node.d.strings[0].d.token.flags;
-                if (tokenFlags & 32 /* StringTokenFlags.Bytes */) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationBytesString(), node);
-                    typeResult = { type: types_1.UnknownType.create() };
-                }
-                else if (tokenFlags & 8 /* StringTokenFlags.Raw */) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationRawString(), node);
-                    typeResult = { type: types_1.UnknownType.create() };
+        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) => {
+            const typeResult = getTypeOfString(expr);
+            if (typeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+            let isExprLiteralString = false;
+            if ((0, types_1.isClassInstance)(typeResult.type)) {
+                if (types_1.ClassType.isBuiltIn(typeResult.type, 'str') && typeResult.type.priv.literalValue !== undefined) {
+                    isExprLiteralString = true;
                 }
-                else if (tokenFlags & 64 /* StringTokenFlags.Format */) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationFormatString(), node);
-                    typeResult = { type: types_1.UnknownType.create() };
+                else if (types_1.ClassType.isBuiltIn(typeResult === null || typeResult === void 0 ? void 0 : typeResult.type, 'LiteralString')) {
+                    isExprLiteralString = true;
                 }
-                else {
-                    // We didn't know at parse time that this string node was going
-                    // to be evaluated as a forward-referenced type. We need
-                    // to re-invoke the parser at this stage.
-                    const expr = parseStringAsTypeAnnotation(node);
-                    if (expr) {
-                        typeResult = getTypeOfExpression(expr, updatedFlags);
-                    }
+            }
+            if (!isExprLiteralString) {
+                isLiteralString = false;
+            }
+        });
+        // Don't create a literal type if it's an f-string.
+        if (node.d.strings.some((str) => str.nodeType === 30 /* ParseNodeType.FormatString */)) {
+            if (isLiteralString) {
+                const literalStringType = getTypingType(node, 'LiteralString');
+                if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
+                    typeResult = { type: types_1.ClassType.cloneAsInstance(literalStringType) };
                 }
             }
             if (!typeResult) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedTypeNotString(), node);
-                typeResult = { type: types_1.UnknownType.create() };
+                typeResult = {
+                    type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
+                    isIncomplete,
+                };
             }
         }
         else {
-            // Evaluate the format string expressions in this context.
-            let isLiteralString = true;
-            let isIncomplete = false;
-            node.d.strings.forEach((expr) => {
-                const typeResult = getTypeOfString(expr);
-                if (typeResult.isIncomplete) {
-                    isIncomplete = true;
-                }
-                let isExprLiteralString = false;
-                if ((0, types_1.isClassInstance)(typeResult.type)) {
-                    if (types_1.ClassType.isBuiltIn(typeResult.type, 'str') &&
-                        typeResult.type.priv.literalValue !== undefined) {
-                        isExprLiteralString = true;
-                    }
-                    else if (types_1.ClassType.isBuiltIn(typeResult === null || typeResult === void 0 ? void 0 : typeResult.type, 'LiteralString')) {
-                        isExprLiteralString = true;
-                    }
-                }
-                if (!isExprLiteralString) {
-                    isLiteralString = false;
+            typeResult = {
+                type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.d.strings.map((s) => s.d.value).join('')),
+                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) {
+        const reportTypeErrors = (flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0;
+        let updatedFlags = flags | 4 /* EvalFlags.ForwardRefs */ | 128 /* EvalFlags.InstantiableType */;
+        let typeResult;
+        // In most cases, annotations within a string are not parsed by the interpreter.
+        // There are a few exceptions (e.g. the "bound" value for a TypeVar constructor).
+        if ((flags & 8388608 /* EvalFlags.ParsesStringLiteral */) === 0) {
+            updatedFlags |= 524288 /* EvalFlags.NotParsed */;
+        }
+        updatedFlags &= ~1073741824 /* EvalFlags.TypeFormArg */;
+        if (node.d.annotation) {
+            return getTypeOfExpression(node.d.annotation, updatedFlags);
+        }
+        if (node.d.strings.length === 1) {
+            const tokenFlags = node.d.strings[0].d.token.flags;
+            if (tokenFlags & 32 /* StringTokenFlags.Bytes */) {
+                if (reportTypeErrors) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationBytesString(), node);
                 }
-            });
-            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) {
-                    const literalStringType = getTypingType(node, 'LiteralString');
-                    if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
-                        typeResult = { type: types_1.ClassType.cloneAsInstance(literalStringType) };
-                    }
+                return { type: types_1.UnknownType.create() };
+            }
+            if (tokenFlags & 8 /* StringTokenFlags.Raw */) {
+                if (reportTypeErrors) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationRawString(), node);
                 }
-                if (!typeResult) {
-                    typeResult = {
-                        type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
-                        isIncomplete,
-                    };
+                return { type: types_1.UnknownType.create() };
+            }
+            if (tokenFlags & 64 /* StringTokenFlags.Format */) {
+                if (reportTypeErrors) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationFormatString(), node);
                 }
+                return { type: types_1.UnknownType.create() };
             }
-            else {
-                typeResult = {
-                    type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.d.strings.map((s) => s.d.value).join('')),
-                    isIncomplete,
-                };
+            // We didn't know at parse time that this string node was going
+            // to be evaluated as a forward-referenced type. We need
+            // to re-invoke the parser at this stage.
+            const expr = parseStringAsTypeAnnotation(node, reportTypeErrors);
+            if (expr) {
+                typeResult = useSpeculativeMode(reportTypeErrors ? undefined : node, () => {
+                    return getTypeOfExpression(expr, updatedFlags);
+                });
             }
         }
+        if (!typeResult) {
+            if (reportTypeErrors) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedTypeNotString(), node);
+            }
+            typeResult = { type: types_1.UnknownType.create() };
+        }
         return typeResult;
     }
     function getTypeOfString(node) {
@@ -1045,7 +1097,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             var _a;
             if ((0, types_1.isClass)(subtype)) {
                 if (subtype.priv.literalValue !== undefined) {
-                    return types_1.ClassType.cloneWithLiteral(subtype, /* value */ undefined);
+                    subtype = types_1.ClassType.cloneWithLiteral(subtype, /* value */ undefined);
                 }
                 if (types_1.ClassType.isBuiltIn(subtype, 'LiteralString')) {
                     // Handle "LiteralString" specially.
@@ -2250,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));
                 }
             }
         }
@@ -2557,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)) {
@@ -2859,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);
             }
         }
     }
@@ -3063,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".
@@ -3096,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;
+        }
+        // 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;
         }
-        // Exempts class types that are created by calling
-        // NewType, NamedTuple, etc.
+        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.
@@ -3123,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, _c;
+        var _a, _b, _c, _d;
         const exemptFlags = 256 /* EvalFlags.TypeExpression */ | 128 /* EvalFlags.InstantiableType */ | 33554432 /* EvalFlags.NoConvertSpecialForm */;
         if ((flags & exemptFlags) !== 0) {
             return type;
@@ -3135,7 +3236,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return type;
             }
         }
-        return (_c = (_b = type.props) === null || _b === void 0 ? void 0 : _b.specialForm) !== null && _c !== void 0 ? _c : type;
+        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
     // scope and captured by an inner scope (a function, lambda, or comprehension).
@@ -3244,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;
@@ -3352,7 +3466,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // type arguments. If so, it fills in these type arguments with Unknown
     // and optionally reports an error.
     function reportMissingTypeArgs(node, type, flags) {
-        var _a, _b, _c;
+        var _a, _b;
         if ((flags & 2 /* EvalFlags.NoSpecialize */) !== 0) {
             return type;
         }
@@ -3372,49 +3486,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Is this a generic type alias that needs to be specialized?
-        const aliasInfo = (_c = type.props) === null || _c === void 0 ? void 0 : _c.typeAliasInfo;
-        if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0 &&
-            aliasInfo &&
-            aliasInfo.typeParams &&
-            aliasInfo.typeParams.length > 0 &&
-            !aliasInfo.typeArgs) {
-            let reportMissingTypeArgs = false;
-            const defaultTypeArgs = [];
-            const constraints = new constraintTracker_1.ConstraintTracker();
-            aliasInfo.typeParams.forEach((param) => {
-                if (!param.shared.isDefaultExplicit) {
-                    reportMissingTypeArgs = true;
-                }
-                let defaultType;
-                if (param.shared.isDefaultExplicit || (0, types_1.isParamSpec)(param)) {
-                    defaultType = solveAndApplyConstraints(param, constraints, {
-                        replaceUnsolved: {
-                            scopeIds: [aliasInfo.typeVarScopeId],
-                            tupleClassType: getTupleClassType(),
-                        },
-                    });
-                }
-                else if ((0, types_1.isTypeVarTuple)(param) && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
-                    defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }], 
-                    /* isUnpacked */ true);
-                }
-                else {
-                    defaultType = types_1.UnknownType.create();
-                }
-                defaultTypeArgs.push(defaultType);
-                constraints.setBounds(param, defaultType);
-            });
-            if (reportMissingTypeArgs) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.typeArgsMissingForAlias().format({
-                    name: aliasInfo.name,
-                }), node);
-            }
-            type = types_1.TypeBase.cloneForTypeAlias(solveAndApplyConstraints(type, constraints, {
-                replaceUnsolved: {
-                    scopeIds: [aliasInfo.typeVarScopeId],
-                    tupleClassType: getTupleClassType(),
-                },
-            }), { ...aliasInfo, typeArgs: defaultTypeArgs });
+        if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0) {
+            type = specializeTypeAliasWithDefaults(type, node);
         }
         return type;
     }
@@ -3748,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);
                     }
@@ -4111,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;
             }
@@ -4701,6 +4774,59 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return true;
     }
+    // If the type is a generic type alias that is not specialized, provides
+    // default type arguments for the type alias. It optionally logs diagnostics
+    // for missing type arguments.
+    function specializeTypeAliasWithDefaults(type, errorNode) {
+        var _a;
+        // Is this a type alias?
+        const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+        if (!aliasInfo) {
+            return type;
+        }
+        // Is this a generic type alias that needs specializing?
+        if (!aliasInfo.typeParams || aliasInfo.typeParams.length === 0 || aliasInfo.typeArgs) {
+            return type;
+        }
+        let reportDiag = false;
+        const defaultTypeArgs = [];
+        const constraints = new constraintTracker_1.ConstraintTracker();
+        aliasInfo.typeParams.forEach((param) => {
+            if (!param.shared.isDefaultExplicit) {
+                reportDiag = true;
+            }
+            let defaultType;
+            if (param.shared.isDefaultExplicit || (0, types_1.isParamSpec)(param)) {
+                defaultType = solveAndApplyConstraints(param, constraints, {
+                    replaceUnsolved: {
+                        scopeIds: [aliasInfo.typeVarScopeId],
+                        tupleClassType: getTupleClassType(),
+                    },
+                });
+            }
+            else if ((0, types_1.isTypeVarTuple)(param) && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
+                defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }], 
+                /* isUnpacked */ true);
+            }
+            else {
+                defaultType = types_1.UnknownType.create();
+            }
+            defaultTypeArgs.push(defaultType);
+            constraints.setBounds(param, defaultType);
+        });
+        if (reportDiag && errorNode) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.typeArgsMissingForAlias().format({
+                name: aliasInfo.name,
+            }), errorNode);
+        }
+        type = types_1.TypeBase.cloneForTypeAlias(solveAndApplyConstraints(type, constraints, {
+            replaceUnsolved: {
+                scopeIds: [aliasInfo.typeVarScopeId],
+                tupleClassType: getTupleClassType(),
+            },
+        }), { ...aliasInfo, typeArgs: defaultTypeArgs });
+        return type;
+    }
     // Handles index expressions that are providing type arguments for a
     // generic type alias.
     function createSpecializedTypeAlias(node, baseType, flags) {
@@ -4719,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
@@ -4745,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({
@@ -4752,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) &&
@@ -4807,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) {
@@ -4853,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 = [];
@@ -4865,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, {
@@ -5299,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,
@@ -5533,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)) {
@@ -5544,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) {
@@ -5586,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 });
             }
         }
@@ -5650,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') {
@@ -5753,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 ||
@@ -5773,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,
@@ -5919,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;
@@ -6044,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
@@ -7120,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);
@@ -7537,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) {
@@ -7558,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,
                                     });
                                 }
@@ -7573,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.
@@ -7593,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);
@@ -7699,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);
@@ -7722,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.
@@ -7773,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,
                                 });
                             }
                         }
@@ -9114,7 +9346,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Specifically disallow Annotated.
         if (((_d = baseClass.props) === null || _d === void 0 ? void 0 : _d.specialForm) &&
-            (0, types_1.isInstantiableClass)(baseClass.props.specialForm) &&
+            (0, types_1.isClassInstance)(baseClass.props.specialForm) &&
             types_1.ClassType.isBuiltIn(baseClass.props.specialForm, 'Annotated')) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeNotAClass(), argList[1].node || errorNode);
             return undefined;
@@ -9183,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 */ ||
@@ -9447,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
@@ -9800,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;
             }
@@ -10334,9 +10570,10 @@ 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;
-        types_1.TypeBase.setSpecialForm(functionType, classType);
+        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);
         if (typeArgs && typeArgs.length > 0) {
@@ -10351,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;
@@ -10412,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) {
@@ -10424,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
@@ -10462,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) {
@@ -10580,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.
@@ -10608,6 +10866,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return type;
     }
+    function createTypeFormType(classType, errorNode, typeArgs) {
+        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({
+                name: classType.priv.aliasName || classType.shared.name,
+                expected: 1,
+                received: typeArgs.length,
+            }), typeArgs[1].node);
+            return types_1.UnknownType.create();
+        }
+        const convertedTypeArgs = typeArgs.map((typeArg) => {
+            return (0, typeUtils_1.convertToInstance)(validateTypeArg(typeArg) ? typeArg.type : types_1.UnknownType.create());
+        });
+        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.
     function createTypeGuardType(classType, errorNode, typeArgs, flags) {
         // If no type arguments are provided, the resulting type
@@ -10626,7 +10905,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const convertedTypeArgs = typeArgs.map((typeArg) => {
             return (0, typeUtils_1.convertToInstance)(validateTypeArg(typeArg) ? typeArg.type : types_1.UnknownType.create());
         });
-        return 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) {
         var _a;
@@ -10701,11 +10984,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return { type: classType };
         }
         if (!typeArgs || typeArgs.length !== 1) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, classType.shared.name === 'ReadOnly'
-                ? localize_1.LocMessage.readOnlyArgCount()
-                : classType.shared.name === 'Required'
-                    ? localize_1.LocMessage.requiredArgCount()
-                    : localize_1.LocMessage.notRequiredArgCount(), errorNode);
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, classType.shared.name === 'ReadOnly'
+                    ? localize_1.LocMessage.readOnlyArgCount()
+                    : classType.shared.name === 'Required'
+                        ? localize_1.LocMessage.requiredArgCount()
+                        : localize_1.LocMessage.notRequiredArgCount(), errorNode);
+            }
             return { type: classType };
         }
         const typeArgType = typeArgs[0].type;
@@ -10743,25 +11028,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isNotRequired = classType.shared.name === 'NotRequired';
         }
         if (!isUsageLegal) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, classType.shared.name === 'ReadOnly'
-                ? localize_1.LocMessage.readOnlyNotInTypedDict()
-                : classType.shared.name === 'Required'
-                    ? localize_1.LocMessage.requiredNotInTypedDict()
-                    : localize_1.LocMessage.notRequiredNotInTypedDict(), errorNode);
-            return { type: types_1.ClassType.specialize(classType, [(0, typeUtils_1.convertToInstance)(typeArgType)], !!typeArgs) };
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, classType.shared.name === 'ReadOnly'
+                    ? localize_1.LocMessage.readOnlyNotInTypedDict()
+                    : classType.shared.name === 'Required'
+                        ? localize_1.LocMessage.requiredNotInTypedDict()
+                        : localize_1.LocMessage.notRequiredNotInTypedDict(), errorNode);
+            }
+            return { type: classType };
         }
         return { type: typeArgType, isReadOnly, isRequired, isNotRequired };
     }
     function createUnpackType(classType, errorNode, typeArgs, flags) {
-        // 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 && (flags & 256 /* EvalFlags.TypeExpression */) === 0) {
-            return classType;
-        }
         if (!typeArgs || typeArgs.length !== 1) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackArgCount(), errorNode);
-            return types_1.UnknownType.create();
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackArgCount(), errorNode);
+            }
+            return classType;
         }
         let typeArgType = typeArgs[0].type;
         if ((0, types_1.isUnion)(typeArgType) && typeArgType.priv.subtypes.length === 1) {
@@ -10774,6 +11057,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, types_1.isTypeVarTuple)(typeArgType) && !typeArgType.priv.isUnpacked) {
                 return types_1.TypeVarType.cloneForUnpacked(typeArgType);
             }
+            if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
+                return classType;
+            }
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypeVarTuple(), errorNode);
             return types_1.UnknownType.create();
         }
@@ -10781,19 +11067,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isTypedDictClass(typeArgType)) {
                 return types_1.ClassType.cloneForUnpacked(typeArgType);
             }
+            if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
+                return classType;
+            }
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypedDict(), errorNode);
             return types_1.UnknownType.create();
         }
+        if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
+            return classType;
+        }
         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackNotAllowed(), errorNode);
         return types_1.UnknownType.create();
     }
     // Creates a "Final" type.
     function createFinalType(classType, errorNode, typeArgs, flags) {
         if (flags & 16 /* EvalFlags.NoFinal */) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.finalContext(), errorNode);
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.finalContext(), errorNode);
+            }
             return classType;
         }
-        if (!typeArgs || typeArgs.length === 0) {
+        if ((flags & 256 /* EvalFlags.TypeExpression */) === 0 || !typeArgs || typeArgs.length === 0) {
             return classType;
         }
         if (typeArgs.length > 1) {
@@ -10803,8 +11097,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function createConcatenateType(classType, errorNode, typeArgs, flags) {
         if ((flags & 134217728 /* EvalFlags.AllowConcatenate */) === 0) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateContext(), errorNode);
-            return types_1.AnyType.create();
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateContext(), errorNode);
+            }
+            return classType;
         }
         if (!typeArgs || typeArgs.length === 0) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateTypeArgsMissing(), errorNode);
@@ -10832,11 +11128,16 @@ 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) {
-            return { type: classType };
+            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 };
         }
-        let type;
         if (typeArgs && typeArgs.length > 0) {
             type = typeArgs[0].type;
             if (typeArgs.length < 2) {
@@ -10853,14 +11154,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[0].node);
         }
         return {
-            type: types_1.TypeBase.cloneAsSpecialForm(type, classType),
+            type: types_1.TypeBase.cloneAsSpecialForm(type, types_1.ClassType.cloneAsInstance(classType)),
             isReadOnly: typeArgs[0].isReadOnly,
             isRequired: typeArgs[0].isRequired,
             isNotRequired: typeArgs[0].isNotRequired,
         };
     }
-    // Enforces metadata consistency as specified in PEP 746 and associates
-    // refinement type predicates with the base type.
+    // Enforces metadata consistency as specified in PEP 746.
     function validateAnnotatedMetadata(errorNode, baseType, metaArgs) {
         for (const metaArg of metaArgs) {
             validateTypeMetadata(errorNode, baseType, metaArg);
@@ -11025,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
@@ -11057,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);
@@ -11066,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
@@ -11107,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;
         }
@@ -11188,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) {
@@ -11309,20 +11627,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     typeParamVariance: 2 /* Variance.Invariant */,
                 },
             ],
+            ['TypeForm', { alias: '', module: 'builtins', isSpecialForm: true, typeParamVariance: 3 /* Variance.Covariant */ }],
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         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;
@@ -11414,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);
                 }
             }
@@ -11722,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));
@@ -11758,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
@@ -12036,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 */;
                         }
                     }
@@ -13042,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) {
@@ -13215,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 {
@@ -13323,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)
@@ -14253,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)) {
@@ -14261,17 +14594,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 case 'Callable': {
                     return { type: createCallableType(classType, typeArgs, errorNode) };
                 }
-                case 'Never': {
-                    if (typeArgs && typeArgs.length > 0) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsExpectingNone().format({ name: 'Never' }), typeArgs[0].node);
-                    }
-                    return { type: types_1.NeverType.createNever() };
-                }
+                case 'Never':
                 case 'NoReturn': {
                     if (typeArgs && typeArgs.length > 0) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsExpectingNone().format({ name: 'NoReturn' }), typeArgs[0].node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsExpectingNone().format({ name: aliasedName }), typeArgs[0].node);
                     }
-                    return { type: 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': {
                     return { type: createOptionalType(classType, errorNode, typeArgs, flags) };
@@ -14283,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': {
@@ -14307,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': {
@@ -14358,6 +14696,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 case 'LiteralString': {
                     return { type: createSpecialType(classType, typeArgs, 0) };
                 }
+                case 'TypeForm': {
+                    return { type: createTypeFormType(classType, errorNode, typeArgs) };
+                }
             }
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
@@ -14382,18 +14723,23 @@ 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)) {
-                return {
-                    type: createSpecialType(classType, typeArgs, 
-                    /* paramLimit */ undefined, 
-                    /* allowParamSpec */ undefined, 
-                    /* isSpecialForm */ false),
-                };
+                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 };
             }
         }
         let typeArgCount = typeArgs ? typeArgs.length : 0;
@@ -14414,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,
@@ -14429,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,
@@ -14436,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
@@ -14444,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.
@@ -14483,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);
                 }
             }
@@ -14574,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]),
@@ -14589,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) {
@@ -14628,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)) {
@@ -14673,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) {
@@ -14929,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;
@@ -14951,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 &&
@@ -14962,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.
@@ -15037,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());
+                            }
                         }
                     }
                 });
@@ -15119,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;
@@ -15665,6 +16038,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return true;
                 }
             }
+            if (decl.type === 2 /* DeclarationType.Param */) {
+                return true;
+            }
             return false;
         });
     }
@@ -15821,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);
@@ -16181,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 */);
@@ -16461,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
@@ -16534,18 +16910,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         inferVarianceForClass(destType);
         // If we're enforcing invariance, literal types must match.
         if ((flags & 1 /* AssignTypeFlags.Invariant */) !== 0) {
-            const srcIsLiteral = srcType.priv.literalValue !== undefined;
-            const destIsLiteral = destType.priv.literalValue !== undefined;
+            const srcIsLiteral = (0, typeUtils_1.isLiteralLikeType)(srcType);
+            const destIsLiteral = (0, typeUtils_1.isLiteralLikeType)(destType);
             if (srcIsLiteral !== destIsLiteral) {
                 return false;
             }
         }
-        else {
-            // If the dest is an 'object', it's assignable.
-            if (types_1.ClassType.isBuiltIn(destType, 'object')) {
-                return true;
-            }
-        }
         for (let ancestorIndex = inheritanceChain.length - 1; ancestorIndex >= 0; ancestorIndex--) {
             const ancestorType = inheritanceChain[ancestorIndex];
             // If we've hit an "unknown", all bets are off, and we need to assume
@@ -16719,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
@@ -16740,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) {
@@ -16753,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) &&
@@ -16804,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;
@@ -16820,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);
@@ -16921,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
@@ -17005,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, 
@@ -17067,7 +17447,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     assignType(destType, concreteSrcType.priv.literalValue.itemType)) {
                     return true;
                 }
-                if (destType.priv.literalValue !== undefined) {
+                if (destType.priv.literalValue !== undefined &&
+                    types_1.ClassType.isSameGenericClass(destType, concreteSrcType)) {
                     const srcLiteral = concreteSrcType.priv.literalValue;
                     if (srcLiteral === undefined || !types_1.ClassType.isLiteralValueSame(concreteSrcType, destType)) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.literalAssignmentMismatch().format({
@@ -17143,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)) {
@@ -17271,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.
@@ -17410,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;
                     }
                 }
@@ -17590,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) => {
@@ -17918,11 +18342,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
             }
-            if (destParam.defaultType && !srcParam.defaultType && paramIndex !== srcParamDetails.argsIndex) {
-                diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
-                    name: srcParamName,
-                }));
-                canAssign = false;
+            if (destParam.defaultType) {
+                if (!srcParam.defaultType && paramIndex !== srcParamDetails.argsIndex) {
+                    diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
+                        name: srcParamName,
+                    }));
+                    canAssign = false;
+                }
+                // If we're performing a partial overload match and both the source
+                // and dest parameters provide defaults, assume that there could
+                // be a match.
+                if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) !== 0) {
+                    if (srcParam.defaultType) {
+                        continue;
+                    }
+                }
             }
             // Handle the special case of an overloaded __init__ method whose self
             // parameter is annotated.
@@ -17993,7 +18427,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // fixed.
                     if (defaultArgType &&
                         !assignType(paramInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
-                        canAssign = false;
+                        if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) === 0) {
+                            canAssign = false;
+                        }
                     }
                     continue;
                 }
@@ -18051,6 +18487,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (destParamDetails.argsIndex !== undefined && destParamDetails.argsIndex < destPositionalCount) {
                     adjDestPositionalCount--;
                 }
+                // If we're doing a partial overload overlap check, ignore dest positional
+                // params with default values.
+                if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) !== 0) {
+                    while (adjDestPositionalCount > 0 &&
+                        destParamDetails.params[adjDestPositionalCount - 1].defaultType) {
+                        adjDestPositionalCount--;
+                    }
+                }
                 if (srcPositionalCount < adjDestPositionalCount) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.functionTooManyParams().format({
                         expected: srcPositionalCount,
@@ -18141,7 +18585,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     const defaultArgType = (_a = srcParamInfo.defaultType) !== null && _a !== void 0 ? _a : srcParamInfo.defaultType;
                                     if (defaultArgType &&
                                         !assignType(srcParamInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
-                                        canAssign = false;
+                                        if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) === 0) {
+                                            canAssign = false;
+                                        }
                                     }
                                 }
                             }
@@ -18245,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
@@ -18998,7 +19442,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 const baseObj = (0, types_1.isClassInstance)(baseType)
                     ? baseType
-                    : types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeClassType)(baseType));
+                    : types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeWithDefaultTypeArgs)(baseType));
                 let stripFirstParam = false;
                 if ((0, types_1.isClassInstance)(baseType)) {
                     stripFirstParam = true;
@@ -19107,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 */:
@@ -19130,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;
     }
@@ -19216,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) {
@@ -19248,7 +19702,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // call produces an expression tree that is not attached to the main parse
     // expression tree because we don't want to mutate the latter; the
     // expression tree created by this function is therefore used only temporarily.
-    function parseStringAsTypeAnnotation(node) {
+    function parseStringAsTypeAnnotation(node, reportErrors) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const parser = new parser_1.Parser();
         const textValue = node.d.strings[0].d.value;
@@ -19269,14 +19723,21 @@ 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 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;
-            // Add the new subtree to the parse tree so it can participate in
-            // language server operations like find and replace.
-            node.d.annotation = parseResults.parseTree;
+            // Optionally add the new subtree to the parse tree so it can
+            // participate in language server operations like find and replace.
+            if (reportErrors) {
+                node.d.annotation = parseResults.parseTree;
+            }
             return parseResults.parseTree;
         }
         return undefined;
@@ -19340,8 +19801,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         isAsymmetricAccessorAssignment,
         suppressDiagnostics,
         isSpecialFormClass,
-        getDeclarationsForStringNode,
-        getDeclarationsForNameNode,
+        getDeclInfoForStringNode,
+        getDeclInfoForNameNode,
         getTypeForDeclaration,
         resolveAliasDeclaration,
         resolveAliasDeclarationWithInfo,