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

package/dist/analyzer/typeEvaluator.js

@@ -891,89 +891,99 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfStringList(node, flags) {
         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() };
+            return getTypeOfStringListAsType(node, flags);
+        }
+        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;
+            }
+        });
+        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) };
                 }
             }
             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,
+            };
+        }
+        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 */;
+        }
+        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;
     }
@@ -1045,7 +1055,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.
@@ -3123,7 +3133,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;
         const exemptFlags = 256 /* EvalFlags.TypeExpression */ | 128 /* EvalFlags.InstantiableType */ | 33554432 /* EvalFlags.NoConvertSpecialForm */;
         if ((flags & exemptFlags) !== 0) {
             return type;
@@ -3135,7 +3145,10 @@ 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;
+        }
+        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).
@@ -3352,7 +3365,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 +3385,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;
     }
@@ -4701,6 +4673,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) {
@@ -9114,7 +9139,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;
@@ -10336,7 +10361,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function createCallableType(classType, typeArgs, errorNode) {
         const functionType = types_1.FunctionType.createInstantiable(0 /* FunctionTypeFlags.None */);
         let paramSpec;
-        types_1.TypeBase.setSpecialForm(functionType, classType);
+        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) {
@@ -10608,6 +10633,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return type;
     }
+    function createTypeFormType(classType, errorNode, typeArgs) {
+        // If no type arguments are provided, the resulting type
+        // depends on whether we're evaluating a type annotation or
+        // we're in some other context.
+        if (!typeArgs) {
+            return classType;
+        }
+        if (typeArgs.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());
+        });
+        const resultType = types_1.ClassType.specialize(classType, convertedTypeArgs);
+        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 +10672,8 @@ 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);
+        const resultType = types_1.ClassType.specialize(classType, convertedTypeArgs);
+        return resultType;
     }
     function createSelfType(classType, errorNode, typeArgs, flags) {
         var _a;
@@ -10701,11 +10748,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 +10792,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 +10821,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 +10831,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 +10861,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 +10892,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
     function createAnnotatedType(classType, errorNode, typeArgs, flags) {
+        let type;
         const typeExprFlags = 256 /* EvalFlags.TypeExpression */ | 33554432 /* EvalFlags.NoConvertSpecialForm */;
         if ((flags & typeExprFlags) === 0) {
-            return { type: classType };
+            type = types_1.ClassType.cloneAsInstance(classType);
+            return { type };
         }
-        let type;
         if (typeArgs && typeArgs.length > 0) {
             type = typeArgs[0].type;
             if (typeArgs.length < 2) {
@@ -10853,14 +10914,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);
@@ -11309,6 +11369,7 @@ 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) {
@@ -14261,17 +14322,13 @@ 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() };
+                    const resultType = aliasedName === 'Never' ? types_1.NeverType.createNever() : types_1.NeverType.createNoReturn();
+                    return { type: resultType };
                 }
                 case 'Optional': {
                     return { type: createOptionalType(classType, errorNode, typeArgs, flags) };
@@ -14358,6 +14415,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);
@@ -14388,12 +14448,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // 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),
-                };
+                const specializedClass = createSpecialType(classType, typeArgs, 
+                /* paramLimit */ undefined, 
+                /* allowParamSpec */ undefined, 
+                /* isSpecialForm */ false);
+                return { type: specializedClass };
             }
         }
         let typeArgCount = typeArgs ? typeArgs.length : 0;
@@ -16534,18 +16593,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
@@ -17067,7 +17120,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({
@@ -17918,11 +17972,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 +18057,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 +18117,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 +18215,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;
+                                        }
                                     }
                                 }
                             }
@@ -18998,7 +19074,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;
@@ -19248,7 +19324,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 +19345,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const parseResults = parser.parseTextExpression(dummyFileContents, valueOffset, textValue.length, parseOptions, 0 /* ParseTextMode.Expression */, 
         /* initialParenDepth */ undefined, fileInfo.typingSymbolAliases);
         if (parseResults.parseTree) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            parseResults.diagnostics.forEach((diag) => {
-                fileInfo.diagnosticSink.addDiagnosticWithTextRange('error', diag.message, node);
-            });
+            if (reportErrors) {
+                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;