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

package/dist/analyzer/typeEvaluator.js

@@ -56,6 +56,7 @@ const analyzerFileInfo_1 = require("./analyzerFileInfo");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const codeFlowEngine_1 = require("./codeFlowEngine");
 const codeFlowTypes_1 = require("./codeFlowTypes");
+const constraintSolution_1 = require("./constraintSolution");
 const constraintSolver_1 = require("./constraintSolver");
 const constraintTracker_1 = require("./constraintTracker");
 const constructors_1 = require("./constructors");
@@ -616,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 */: {
@@ -888,9 +888,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
-    function getTypeOfStringList(node, flags, isExpectingType) {
+    function getTypeOfStringList(node, flags) {
         let typeResult;
-        if (isExpectingType) {
+        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).
@@ -900,7 +900,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (node.d.annotation) {
                 typeResult = getTypeOfExpression(node.d.annotation, updatedFlags);
             }
-            else if (!node.d.annotation && node.d.strings.length === 1) {
+            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);
@@ -2093,20 +2093,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);
     }
@@ -3410,7 +3396,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else if ((0, types_1.isTypeVarTuple)(param) && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
                     defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }], 
-                    /* isUnpackedTuple */ true);
+                    /* isUnpacked */ true);
                 }
                 else {
                     defaultType = types_1.UnknownType.create();
@@ -3789,8 +3775,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (usage.method === 'get') {
                         const getAttrSymbol = types_1.ModuleType.getField(baseType, '__getattr__');
                         if (getAttrSymbol) {
-                            const isModuleGetAttrSupported = fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_7) ||
-                                getAttrSymbol.getDeclarations().some((decl) => decl.uri.hasExtension('.pyi'));
+                            const isModuleGetAttrSupported = pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_7) || getAttrSymbol.getDeclarations().some((decl) => decl.uri.hasExtension('.pyi'));
                             if (isModuleGetAttrSupported) {
                                 const getAttrTypeResult = getEffectiveTypeOfSymbolForUsage(getAttrSymbol);
                                 if ((0, types_1.isFunction)(getAttrTypeResult.type)) {
@@ -4550,7 +4535,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     !baseTypeResult.type.priv.aliasName) {
                     const minPythonVersion = nonSubscriptableBuiltinTypes.get(baseTypeResult.type.shared.fullName);
                     if (minPythonVersion !== undefined &&
-                        fileInfo.executionEnvironment.pythonVersion.isLessThan(minPythonVersion) &&
+                        pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, minPythonVersion) &&
                         !fileInfo.isStubFile) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.classNotRuntimeSubscriptable().format({
                             name: baseTypeResult.type.priv.aliasName || baseTypeResult.type.shared.name,
@@ -4687,7 +4672,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                         });
                     }
-                    const tupleObject = makeTupleObject(variadicTypes, /* isUnpackedTuple */ true);
+                    const tupleObject = makeTupleObject(variadicTypes, /* isUnpacked */ true);
                     typeArgs = [
                         ...typeArgs.slice(0, variadicIndex),
                         { node: typeArgs[variadicIndex].node, type: tupleObject },
@@ -4699,7 +4684,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Add an empty tuple that maps to the TypeVarTuple type parameter.
                 typeArgs.push({
                     node: errorNode,
-                    type: makeTupleObject([], /* isUnpackedTuple */ true),
+                    type: makeTupleObject([], /* isUnpacked */ true),
                 });
             }
         }
@@ -5148,9 +5133,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         });
     }
-    function makeTupleObject(typeArgs, isUnpackedTuple = false) {
+    function makeTupleObject(typeArgs, isUnpacked = false) {
         if (tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
-            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClass, typeArgs, /* isTypeArgExplicit */ true, isUnpackedTuple));
+            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClass, typeArgs, /* isTypeArgExplicit */ true, isUnpacked));
         }
         return types_1.UnknownType.create();
     }
@@ -7196,7 +7181,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else {
                     positionalOnlyLimitIndex = varArgListParamIndex;
-                    positionalArgCount = varArgListParamIndex;
+                    positionalArgCount = Math.min(varArgListParamIndex, positionalArgCount);
                     positionParamLimitIndex = varArgListParamIndex;
                 }
             }
@@ -7930,7 +7915,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         specializedTuple = tupleTypeArgs[0].type;
                     }
                     else {
-                        specializedTuple = makeTupleObject(tupleTypeArgs, /* isUnpackedTuple */ true);
+                        specializedTuple = makeTupleObject(tupleTypeArgs, /* isUnpacked */ true);
                     }
                     const combinedArg = {
                         paramCategory: 1 /* ParamCategory.ArgsList */,
@@ -8263,10 +8248,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
-            specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpackedTuple */ false);
+            specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpacked */ false);
         }
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
-        specializedReturnType = adjustCallableReturnType(type, specializedReturnType, liveTypeVarScopes);
+        specializedReturnType = adjustCallableReturnType(errorNode, specializedReturnType, liveTypeVarScopes);
         if (specializedInitSelfType) {
             specializedInitSelfType = solveAndApplyConstraints(specializedInitSelfType, constraints);
         }
@@ -8313,21 +8298,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // to allow these type vars to be solved. This won't work with overloads
     // or unions of callables. It's intended for a specific use case. We may
     // need to make this more sophisticated in the future.
-    function adjustCallableReturnType(callableType, returnType, liveTypeVarScopes) {
-        var _a, _b;
-        if (!(0, types_1.isFunction)(returnType) || returnType.shared.name || !callableType.shared.typeVarScopeId) {
+    function adjustCallableReturnType(callNode, returnType, liveTypeVarScopes) {
+        if (!(0, types_1.isFunction)(returnType)) {
             return returnType;
         }
         // What type variables are referenced in the callable return type? Do not include any live type variables.
-        const newTypeParams = (0, typeUtils_1.getTypeVarArgsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.priv.scopeId === scopeId));
+        const typeParams = (0, typeUtils_1.getTypeVarArgsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.priv.scopeId === scopeId));
         // If there are no unsolved type variables, we're done. If there are
-        // unsolved type variables, treat them as though they are rescoped
-        // to the callable.
-        if (newTypeParams.length === 0) {
+        // unsolved type variables, rescope them to the callable.
+        if (typeParams.length === 0) {
             return returnType;
         }
-        const newScopeId = (_b = (_a = newTypeParams[0].priv.freeTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) !== null && _b !== void 0 ? _b : newTypeParams[0].priv.scopeId;
-        return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, newScopeId, callableType.priv.constructorTypeVarScopeId, newTypeParams);
+        inferReturnTypeIfNecessary(returnType);
+        // Create a new scope ID based on the caller's position. This
+        // will guarantee uniqueness. If another caller uses the same
+        // call and arguments, the type vars will not conflict.
+        const newScopeId = ParseTreeUtils.getScopeIdForNode(callNode);
+        const solution = new constraintSolution_1.ConstraintSolution();
+        const newTypeParams = typeParams.map((typeVar) => {
+            const newTypeParam = types_1.TypeVarType.cloneForScopeId(typeVar, newScopeId, typeVar.priv.scopeName, 1 /* TypeVarScopeType.Function */);
+            solution.setType(typeVar, newTypeParam);
+            return newTypeParam;
+        });
+        return (0, typeUtils_1.applySolvedTypeVars)(types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, newScopeId, 
+        /* constructorTypeVarScopeId */ undefined, newTypeParams), solution);
     }
     // Tries to assign the call arguments to the function parameter
     // list and reports any mismatches in types or counts. Returns the
@@ -8746,7 +8740,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     typeVar.shared.isDefaultExplicit = true;
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
-                        fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_13) &&
+                        pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), defaultValueNode);
                     }
@@ -8850,7 +8844,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
-                        fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_13) &&
+                        pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), expr);
                     }
@@ -8911,7 +8905,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
-                        fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_13) &&
+                        pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), expr);
                     }
@@ -10074,7 +10068,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) {
@@ -10614,10 +10608,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return type;
     }
-    // Creates a "TypeGuard" and "TypeIs" type. This is an alias for 'bool', which
-    // isn't a generic type and therefore doesn't have a typeParam.
-    // We'll abuse our internal types a bit by specializing it with
-    // a type argument anyway.
+    // Creates a "TypeGuard" and "TypeIs" type.
     function createTypeGuardType(classType, errorNode, typeArgs, flags) {
         // If no type arguments are provided, the resulting type
         // depends on whether we're evaluating a type annotation or
@@ -10845,65 +10836,77 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & typeExprFlags) === 0) {
             return { type: classType };
         }
-        if (typeArgs) {
+        let type;
+        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, 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) {
+    // Enforces metadata consistency as specified in PEP 746 and associates
+    // refinement type predicates with the base type.
+    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",
@@ -11043,36 +11046,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             })) {
                 typeArgType = types_1.UnknownType.create();
             }
-            // If this is an unpacked tuple, explode out the individual items.
-            if ((0, types_1.isUnpackedClass)(typeArg.type) && typeArg.type.priv.tupleTypeArgs) {
+            if ((0, types_1.isTypeVar)(typeArgType) && (0, types_1.isUnpackedTypeVarTuple)(typeArgType)) {
                 // This is an experimental feature because Unions of unpacked TypeVarTuples are not officially supported.
                 if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
-                    typeArg.type.priv.tupleTypeArgs.forEach((tupleTypeArg) => {
-                        types.push((0, typeUtils_1.convertToInstantiable)(tupleTypeArg.type));
-                    });
+                    // If this is an unpacked TypeVar, note that it is in a union so we can
+                    // differentiate between Unpack[Vs] and Union[Unpack[Vs]].
+                    typeArgType = types_1.TypeVarType.cloneForUnpacked(typeArgType, /* isInUnion */ true);
                     allowSingleTypeArg = true;
                 }
                 else {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionUnpackedTuple(), errorNode);
-                    types.push(types_1.UnknownType.create());
-                }
-            }
-            else {
-                if ((0, types_1.isTypeVar)(typeArgType) && (0, types_1.isUnpackedTypeVarTuple)(typeArgType)) {
-                    // This is an experimental feature because Unions of unpacked TypeVarTuples are not officially supported.
-                    if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
-                        // If this is an unpacked TypeVar, note that it is in a union so we can
-                        // differentiate between Unpack[Vs] and Union[Unpack[Vs]].
-                        typeArgType = types_1.TypeVarType.cloneForUnpacked(typeArgType, /* isInUnion */ true);
-                        allowSingleTypeArg = true;
-                    }
-                    else {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionUnpackedTypeVarTuple(), errorNode);
-                        typeArgType = types_1.UnknownType.create();
-                    }
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionUnpackedTypeVarTuple(), errorNode);
+                    typeArgType = types_1.UnknownType.create();
                 }
-                types.push(typeArgType);
             }
+            types.push(typeArgType);
         }
         // Validate that we received at least two type arguments. One type argument
         // is allowed if it's an unpacked TypeVarTuple or tuple. None is also allowed
@@ -11229,7 +11216,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (fileInfo.isTypingExtensionsStubFile) {
             specialClassType.shared.flags |= 4096 /* ClassTypeFlags.TypingExtensionClass */;
         }
-        const baseClassName = aliasMapEntry.alias || 'object';
+        const baseClassName = aliasMapEntry.implicitBaseClass || aliasMapEntry.alias || 'object';
         let baseClass;
         if (aliasMapEntry.module === 'builtins') {
             baseClass = getBuiltInType(node, baseClassName);
@@ -11296,7 +11283,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             ['Concatenate', { alias: '', module: 'builtins', isSpecialForm: true }],
             [
                 'TypeGuard',
-                { alias: '', module: 'builtins', isSpecialForm: true, typeParamVariance: 3 /* Variance.Covariant */ },
+                {
+                    alias: '',
+                    module: 'builtins',
+                    implicitBaseClass: 'bool',
+                    isSpecialForm: true,
+                    typeParamVariance: 3 /* Variance.Covariant */,
+                },
             ],
             ['Unpack', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['Required', { alias: '', module: 'builtins', isSpecialForm: true }],
@@ -11306,7 +11299,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             ['Never', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['LiteralString', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['ReadOnly', { alias: '', module: 'builtins', isSpecialForm: true }],
-            ['TypeIs', { alias: '', module: 'builtins', isSpecialForm: true, typeParamVariance: 2 /* Variance.Invariant */ }],
+            [
+                'TypeIs',
+                {
+                    alias: '',
+                    module: 'builtins',
+                    implicitBaseClass: 'bool',
+                    isSpecialForm: true,
+                    typeParamVariance: 2 /* Variance.Invariant */,
+                },
+            ],
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
@@ -11743,7 +11745,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (types_1.ClassType.isBuiltIn(argType, 'Protocol')) {
                                 if (!fileInfo.isStubFile &&
                                     !types_1.ClassType.isTypingExtensionClass(argType) &&
-                                    fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_7)) {
+                                    pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_7)) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.protocolIllegal(), arg.d.valueExpr);
                                 }
                                 classType.shared.flags |= 512 /* ClassTypeFlags.ProtocolClass */;
@@ -11753,7 +11755,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                             // If the class directly derives from NamedTuple (in Python 3.6 or
                             // newer), it's considered a (read-only) dataclass.
-                            if (fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_6)) {
+                            if (pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_6)) {
                                 if (types_1.ClassType.isBuiltIn(argType, 'NamedTuple')) {
                                     isNamedTupleSubclass = true;
                                     classType.shared.flags |= 524288 /* ClassTypeFlags.ReadOnlyInstanceVariables */;
@@ -12817,7 +12819,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);
@@ -13064,7 +13066,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return type;
                 }
                 if ((0, types_1.isUnpackedClass)(type)) {
-                    return types_1.ClassType.cloneForUnpacked(type, /* isUnpackedTuple */ false);
+                    return types_1.ClassType.cloneForUnpacked(type, /* isUnpacked */ false);
                 }
                 return makeTupleObject([{ type, isUnbounded: !(0, types_1.isTypeVarTuple)(type) }]);
             }
@@ -13531,7 +13533,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     reportError = true;
                     // Handle PEP 562 support for module-level __getattr__ function,
                     // introduced in Python 3.7.
-                    if (fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_7) ||
+                    if (pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_7) ||
                         fileInfo.isStubFile) {
                         const getAttrSymbol = importLookupInfo.symbolTable.get('__getattr__');
                         if (getAttrSymbol) {
@@ -14360,7 +14362,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         if (fileInfo.isStubFile ||
-            fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_9) ||
+            pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_9) ||
             (0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(errorNode)) ||
             (flags & 4 /* EvalFlags.ForwardRefs */) !== 0) {
             // Handle "type" specially, since it needs to act like "Type"
@@ -15053,7 +15055,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]));
                 }
             }
         }
@@ -16374,13 +16376,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return true;
         }
-        // If the type is a bool created with a `TypeGuard` or `TypeIs`, it is
-        // considered a subtype of `bool`.
-        if ((0, types_1.isInstantiableClass)(srcType) && types_1.ClassType.isBuiltIn(srcType, ['TypeGuard', 'TypeIs'])) {
-            if ((0, types_1.isInstantiableClass)(destType) && types_1.ClassType.isBuiltIn(destType, 'bool')) {
-                return (flags & 1 /* AssignTypeFlags.Invariant */) === 0;
-            }
-        }
         if ((flags & 1 /* AssignTypeFlags.Invariant */) === 0 || types_1.ClassType.isSameGenericClass(srcType, destType)) {
             if (isDerivedFrom) {
                 (0, debug_1.assert)(inheritanceChain.length > 0);
@@ -16587,14 +16582,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);
@@ -16616,7 +16603,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const typeParam = destType.shared.typeParams[i];
                 const variance = types_1.TypeVarType.getVariance(typeParam);
                 if (curSrcType.priv.tupleTypeArgs) {
-                    typeArgType = (0, typeUtils_1.convertToInstance)(makeTupleObject(curSrcType.priv.tupleTypeArgs, /* isUnpackedTuple */ true));
+                    typeArgType = (0, typeUtils_1.convertToInstance)(makeTupleObject(curSrcType.priv.tupleTypeArgs, /* isUnpacked */ true));
                 }
                 else {
                     typeArgType = i < srcTypeArgs.length ? srcTypeArgs[i] : types_1.UnknownType.create();
@@ -17733,7 +17720,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        return getBoundMagicMethod(objType, '__call__', /* selfType */ undefined, /* diag */ undefined, recursionCount);
+        const callType = getBoundMagicMethod(objType, '__call__', 
+        /* selfType */ undefined, 
+        /* diag */ undefined, recursionCount);
+        if (!callType) {
+            return undefined;
+        }
+        return (0, typeUtils_1.makeFunctionTypeVarsBound)(callType);
     }
     function assignParam(destType, srcType, paramIndex, diag, constraints, flags, recursionCount) {
         // Handle the special case where the dest type is a synthesized
@@ -17839,7 +17832,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         });
         if (srcTupleTypes.length !== 1 || !(0, types_1.isTypeVarTuple)(srcTupleTypes[0].type)) {
-            const srcPositionalsType = makeTupleObject(srcTupleTypes, /* isUnpackedTuple */ true);
+            const srcPositionalsType = makeTupleObject(srcTupleTypes, /* isUnpacked */ true);
             // Snip out the portion of the source positionals that map to the variadic
             // dest parameter and replace it with a single parameter that is typed as a
             // tuple containing the individual types of the replaced parameters.
@@ -18075,10 +18068,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let destArgsType = destParamDetails.params[destParamDetails.argsIndex].type;
             let srcArgsType = srcParamDetails.params[srcParamDetails.argsIndex].type;
             if (!(0, types_1.isUnpacked)(destArgsType)) {
-                destArgsType = makeTupleObject([{ type: destArgsType, isUnbounded: true }], /* isUnpackedTuple */ true);
+                destArgsType = makeTupleObject([{ type: destArgsType, isUnbounded: true }], /* isUnpacked */ true);
             }
             if (!(0, types_1.isUnpacked)(srcArgsType)) {
-                srcArgsType = makeTupleObject([{ type: srcArgsType, isUnbounded: true }], /* isUnpackedTuple */ true);
+                srcArgsType = makeTupleObject([{ type: srcArgsType, isUnbounded: true }], /* isUnpacked */ true);
             }
             if (!assignParam(destArgsType, srcArgsType, destParamDetails.params[destParamDetails.argsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                 canAssign = false;
@@ -18254,7 +18247,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
@@ -19076,7 +19069,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));
@@ -19265,14 +19266,17 @@ 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 */) {
+        if (parseResults.parseTree) {
+            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
             parseResults.diagnostics.forEach((diag) => {
-                addDiagnosticWithSuppressionCheck('error', diag.message, node);
+                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;
             return parseResults.parseTree;
         }
         return undefined;