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

package/dist/analyzer/typeEvaluator.js

@@ -617,13 +617,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 48 /* ParseNodeType.StringList */: {
-                const isExpectingType = (flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0 && !isAnnotationLiteralValue(node);
-                if (isExpectingType) {
+                if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0) {
                     // Don't report expecting type errors again. We will have already
                     // reported them when analyzing the contents of the string.
                     expectingInstantiable = false;
                 }
-                typeResult = getTypeOfStringList(node, flags, isExpectingType);
+                typeResult = getTypeOfStringList(node, flags);
                 break;
             }
             case 40 /* ParseNodeType.Number */: {
@@ -889,92 +888,102 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
-    function getTypeOfStringList(node, flags, isExpectingType) {
+    function getTypeOfStringList(node, flags) {
         let typeResult;
-        if (isExpectingType) {
-            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.annotation && 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() };
+        if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0) {
+            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 & 8 /* StringTokenFlags.Raw */) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationRawString(), 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 if (tokenFlags & 64 /* StringTokenFlags.Format */) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationFormatString(), node);
-                    typeResult = { type: types_1.UnknownType.create() };
-                }
-                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;
     }
@@ -1046,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.
@@ -2094,20 +2103,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return (codeFlowEngine.getFlowNodeReachability(sinkFlowNode, sourceFlowNode, /* ignoreNoReturn */ true) ===
             typeEvaluatorTypes_1.Reachability.Reachable);
     }
-    // Determines whether the specified string literal is part
-    // of a Literal['xxx'] statement. If so, we will not treat
-    // the string as a normal forward-declared type annotation.
-    function isAnnotationLiteralValue(node) {
-        if (node.parent && node.parent.nodeType === 27 /* ParseNodeType.Index */) {
-            const baseType = getTypeOfExpression(node.parent.d.leftExpr).type;
-            if (baseType && (0, types_1.isInstantiableClass)(baseType)) {
-                if (types_1.ClassType.isSpecialBuiltIn(baseType, 'Literal')) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
     function addInformation(message, node, range) {
         return addDiagnosticWithSuppressionCheck('information', message, node, range);
     }
@@ -3138,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;
@@ -3150,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).
@@ -3367,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;
         }
@@ -3387,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;
     }
@@ -4716,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) {
@@ -9129,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;
@@ -10083,7 +10093,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         paramsArePositionOnly = false;
                     }
                 }
-                const functionParam = types_1.FunctionParam.create(param.d.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(), types_1.FunctionParamFlags.TypeDeclared, param.d.name ? param.d.name.d.value : undefined, param.d.defaultValue ? types_1.AnyType.create(/* isEllipsis */ true) : undefined);
+                const functionParam = types_1.FunctionParam.create(param.d.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(), types_1.FunctionParamFlags.TypeDeclared, param.d.name ? param.d.name.d.value : undefined, param.d.defaultValue ? types_1.AnyType.create(/* isEllipsis */ true) : undefined, param.d.defaultValue);
                 types_1.FunctionType.addParam(functionType, functionParam);
             });
             if (paramsArePositionOnly && functionType.shared.parameters.length > 0) {
@@ -10351,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) {
@@ -10623,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
@@ -10641,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;
@@ -10716,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;
@@ -10758,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) {
@@ -10789,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();
         }
@@ -10796,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) {
@@ -10818,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);
@@ -10847,69 +10892,81 @@ 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 };
         }
-        if (typeArgs) {
+        if (typeArgs && typeArgs.length > 0) {
+            type = typeArgs[0].type;
             if (typeArgs.length < 2) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotatedTypeArgMissing(), errorNode);
             }
             else {
-                validateAnnotatedMetadata(errorNode, typeArgs[0].type, typeArgs.slice(1));
+                type = validateAnnotatedMetadata(errorNode, typeArgs[0].type, typeArgs.slice(1));
             }
         }
-        if (!typeArgs || typeArgs.length === 0) {
+        if (!type || !typeArgs || typeArgs.length === 0) {
             return { type: types_1.AnyType.create() };
         }
         if (typeArgs[0].typeList) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListNotAllowed(), typeArgs[0].node);
         }
         return {
-            type: types_1.TypeBase.cloneAsSpecialForm(typeArgs[0].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.
-    function validateAnnotatedMetadata(errorNode, annotatedType, metaArgs) {
+    function validateAnnotatedMetadata(errorNode, baseType, metaArgs) {
+        for (const metaArg of metaArgs) {
+            validateTypeMetadata(errorNode, baseType, metaArg);
+        }
+        return baseType;
+    }
+    // Determines whether the metadata object is compatible with the base type.
+    function validateTypeMetadata(errorNode, baseType, metaArg) {
         var _a;
         // This is an experimental feature because PEP 746 hasn't been accepted.
         if (!AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
-            return;
+            return true;
         }
-        for (const metaArg of metaArgs) {
-            if ((0, types_1.isClass)(metaArg.type)) {
-                const supportsTypeMethod = (_a = getTypeOfBoundMember(
-                /* errorNode */ undefined, metaArg.type, '__supports_type__')) === null || _a === void 0 ? void 0 : _a.type;
-                if (!supportsTypeMethod) {
-                    continue;
-                }
-                // "Call" the __supports_type__ method to determine if the type is supported.
-                const callResult = useSpeculativeMode(errorNode, () => validateCallArgs(errorNode, [
-                    {
-                        argCategory: 0 /* ArgCategory.Simple */,
-                        typeResult: { type: (0, typeUtils_1.convertToInstance)(annotatedType) },
-                    },
-                ], { type: supportsTypeMethod }, 
-                /* constraints */ undefined, 
-                /* skipUnknownArgCheck */ true, 
-                /* inferenceContext */ undefined));
-                if (callResult.isTypeIncomplete || !callResult.returnType) {
-                    continue;
-                }
-                // If there are no errors and the return type is potentially truthy,
-                // we know that the type is supported by this metadata object.
-                if (!callResult.argumentErrors && canBeTruthy(callResult.returnType)) {
-                    continue;
-                }
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.annotatedMetadataInconsistent().format({
-                    metadataType: printType(metaArg.type),
-                    type: printType((0, typeUtils_1.convertToInstance)(annotatedType)),
-                }), metaArg.node);
-            }
+        if (!(0, types_1.isClass)(metaArg.type)) {
+            return true;
+        }
+        const supportsTypeMethod = (_a = getTypeOfBoundMember(
+        /* errorNode */ undefined, metaArg.type, '__supports_type__')) === null || _a === void 0 ? void 0 : _a.type;
+        if (!supportsTypeMethod) {
+            return true;
+        }
+        // "Call" the __supports_type__ method to determine if the type is supported.
+        const callResult = useSpeculativeMode(errorNode, () => validateCallArgs(errorNode, [
+            {
+                argCategory: 0 /* ArgCategory.Simple */,
+                typeResult: { type: (0, typeUtils_1.convertToInstance)(baseType) },
+            },
+        ], { type: supportsTypeMethod }, 
+        /* constraints */ undefined, 
+        /* skipUnknownArgCheck */ true, 
+        /* inferenceContext */ undefined));
+        if (!callResult.returnType) {
+            return true;
         }
+        // If there are no errors and the return type is potentially truthy,
+        // we know that the type is supported by this metadata object.
+        if (!callResult.argumentErrors && canBeTruthy(callResult.returnType)) {
+            return true;
+        }
+        if (!callResult.isTypeIncomplete) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.annotatedMetadataInconsistent().format({
+                metadataType: printType(metaArg.type),
+                type: printType((0, typeUtils_1.convertToInstance)(baseType)),
+            }), metaArg.node);
+        }
+        return false;
     }
     // Creates one of several "special" types that are defined in typing.pyi
     // but not declared in their entirety. This includes the likes of "Tuple",
@@ -11312,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) {
@@ -12822,7 +12880,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 paramType = paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create();
                 const functionParam = types_1.FunctionParam.create(param.d.category, paramType, (isTypeInferred ? types_1.FunctionParamFlags.TypeInferred : types_1.FunctionParamFlags.None) |
-                    (paramTypeNode ? types_1.FunctionParamFlags.TypeDeclared : types_1.FunctionParamFlags.None), param.d.name ? param.d.name.d.value : undefined, defaultValueType);
+                    (paramTypeNode ? types_1.FunctionParamFlags.TypeDeclared : types_1.FunctionParamFlags.None), param.d.name ? param.d.name.d.value : undefined, defaultValueType, param.d.defaultValue);
                 types_1.FunctionType.addParam(functionType, functionParam);
                 if (types_1.FunctionParam.isTypeDeclared(functionParam)) {
                     (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParamsSeen, (0, typeUtils_1.getTypeVarArgsRecursive)(paramType), functionType.shared.typeVarScopeId);
@@ -14264,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) };
@@ -14361,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);
@@ -14391,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;
@@ -15058,7 +15114,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Synthesize an alias declaration for this name part. The only
                     // time this case is used is for IDE services such as
                     // the find all references, hover provider and etc.
-                    declarations.push((0, declarationUtils_1.createSynthesizedAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
+                    declarations.push((0, declarationUtils_1.synthesizeAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
                 }
             }
         }
@@ -16537,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
@@ -16585,14 +16635,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             prevSrcType = curSrcType;
         }
-        // If we're enforcing invariance, literal types must match as well.
-        if ((flags & 1 /* AssignTypeFlags.Invariant */) !== 0) {
-            const srcIsLiteral = srcType.priv.literalValue !== undefined;
-            const destIsLiteral = destType.priv.literalValue !== undefined;
-            if (srcIsLiteral !== destIsLiteral) {
-                return false;
-            }
-        }
         // Handle tuple, which supports a variable number of type arguments.
         if (destType.priv.tupleTypeArgs && curSrcType.priv.tupleTypeArgs) {
             return (0, tuples_1.assignTupleTypeArgs)(evaluatorInterface, destType, curSrcType, diag, constraints, flags, recursionCount);
@@ -17078,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({
@@ -17929,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.
@@ -18004,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;
                 }
@@ -18062,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,
@@ -18152,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;
+                                        }
                                     }
                                 }
                             }
@@ -18258,7 +18323,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     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));
+                            : undefined, p.defaultExpr));
                     }
                 });
                 // If there are remaining parameters and the source and dest do not contain
@@ -19009,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;
@@ -19080,7 +19145,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // evaluating (and caching) the inferred return type if there is no defined return type.
         getEffectiveReturnType(memberType);
         const specializedFunction = solveAndApplyConstraints(memberType, constraints);
-        return types_1.FunctionType.clone(specializedFunction, stripFirstParam, baseType);
+        if ((0, types_1.isFunction)(specializedFunction)) {
+            return types_1.FunctionType.clone(specializedFunction, stripFirstParam, baseType);
+        }
+        if ((0, types_1.isOverloaded)(specializedFunction)) {
+            // For overloaded functions, use the first overload. This isn't
+            // strictly correct, but this is an extreme edge case.
+            return types_1.FunctionType.clone(types_1.OverloadedType.getOverloads(specializedFunction)[0], stripFirstParam, baseType);
+        }
+        return undefined;
     }
     function isFinalVariable(symbol) {
         return symbol.getDeclarations().some((decl) => isFinalVariableDeclaration(decl));
@@ -19251,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 +19342,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         parseOptions.isStubFile = fileInfo.isStubFile;
         parseOptions.pythonVersion = fileInfo.executionEnvironment.pythonVersion;
         parseOptions.reportErrorsForParsedStringContents = true;
-        const parseResults = parser.parseTextExpression(dummyFileContents, valueOffset, textValue.length, parseOptions, 
-        /* parseTextMode */ undefined, 
+        const parseResults = parser.parseTextExpression(dummyFileContents, valueOffset, textValue.length, parseOptions, 0 /* ParseTextMode.Expression */, 
         /* initialParenDepth */ undefined, fileInfo.typingSymbolAliases);
-        if (parseResults.parseTree && parseResults.parseTree.nodeType !== 62 /* ParseNodeType.FunctionAnnotation */) {
-            parseResults.diagnostics.forEach((diag) => {
-                addDiagnosticWithSuppressionCheck('error', diag.message, node);
-            });
+        if (parseResults.parseTree) {
+            if (reportErrors) {
+                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                parseResults.diagnostics.forEach((diag) => {
+                    fileInfo.diagnosticSink.addDiagnosticWithTextRange('error', diag.message, node);
+                });
+            }
             parseResults.parseTree.parent = node;
+            // Optionally add the new subtree to the parse tree so it can
+            // participate in language server operations like find and replace.
+            if (reportErrors) {
+                node.d.annotation = parseResults.parseTree;
+            }
             return parseResults.parseTree;
         }
         return undefined;