coc-pyright 1.1.315 → 1.1.316

package/lib/index.js

@@ -18646,7 +18646,6 @@ var require_package_nls_en_us = __commonJS({
         protocolBaseClass: 'Protocol class "{classType}" cannot derive from non-protocol class "{baseType}"',
         protocolBaseClassWithTypeArgs: "Type arguments are not allowed with Protocol class when using type parameter syntax",
         protocolIllegal: 'Use of "Protocol" requires Python 3.7 or newer',
-        protocolMemberNotClassVar: 'Protocol class "{className}" does not define "{memberName}" as a ClassVar',
         protocolNotAllowedInTypeArgument: '"Protocol" cannot be used as a type argument',
         protocolUsedInCall: 'Protocol class cannot be used in "{name}" call',
         protocolVarianceContravariant: 'Type variable "{variable}" used in generic protocol "{class}" should be contravariant',
@@ -19549,7 +19548,6 @@ var require_localize = __commonJS({
         Diagnostic6.protocolBaseClass = () => new ParameterizedString(getRawString("Diagnostic.protocolBaseClass"));
         Diagnostic6.protocolBaseClassWithTypeArgs = () => getRawString("Diagnostic.protocolBaseClassWithTypeArgs");
         Diagnostic6.protocolIllegal = () => getRawString("Diagnostic.protocolIllegal");
-        Diagnostic6.protocolMemberNotClassVar = () => new ParameterizedString(getRawString("Diagnostic.protocolMemberNotClassVar"));
         Diagnostic6.protocolNotAllowedInTypeArgument = () => getRawString("Diagnostic.protocolNotAllowedInTypeArgument");
         Diagnostic6.protocolUsedInCall = () => new ParameterizedString(getRawString("Diagnostic.protocolUsedInCall"));
         Diagnostic6.protocolVarianceContravariant = () => new ParameterizedString(getRawString("Diagnostic.protocolVarianceContravariant"));
@@ -28247,7 +28245,7 @@ var require_types = __commonJS({
         return clone;
       }
       TypeBase2.cloneType = cloneType;
-      function cloneTypeAsInstance(type) {
+      function cloneTypeAsInstance(type, cache) {
         (0, debug_1.assert)(TypeBase2.isInstantiable(type));
         const newInstance = TypeBase2.cloneType(type);
         if (newInstance.instantiableNestingLevel === void 0) {
@@ -28261,10 +28259,16 @@ var require_types = __commonJS({
             newInstance.instantiableNestingLevel--;
           }
         }
+        if (cache) {
+          if (!type.cached) {
+            type.cached = {};
+          }
+          type.cached.typeBaseInstanceType = newInstance;
+        }
         return newInstance;
       }
       TypeBase2.cloneTypeAsInstance = cloneTypeAsInstance;
-      function cloneTypeAsInstantiable(type) {
+      function cloneTypeAsInstantiable(type, cache) {
         const newInstance = TypeBase2.cloneType(type);
         if (TypeBase2.isInstance(type)) {
           newInstance.flags &= ~2;
@@ -28272,6 +28276,12 @@ var require_types = __commonJS({
         } else {
           newInstance.instantiableNestingLevel = newInstance.instantiableNestingLevel === void 0 ? 1 : newInstance.instantiableNestingLevel;
         }
+        if (cache) {
+          if (!type.cached) {
+            type.cached = {};
+          }
+          type.cached.typeBaseInstantiableType = newInstance;
+        }
         return newInstance;
       }
       TypeBase2.cloneTypeAsInstantiable = cloneTypeAsInstantiable;
@@ -28437,10 +28447,18 @@ var require_types = __commonJS({
       }
       ClassType2.createInstantiable = createInstantiable;
       function cloneAsInstance(type, includeSubclasses = true) {
+        var _a;
         if (TypeBase.isInstance(type)) {
           return type;
         }
-        const newInstance = TypeBase.cloneTypeAsInstance(type);
+        if (includeSubclasses && ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstanceType)) {
+          return type.cached.typeBaseInstanceType;
+        }
+        const newInstance = TypeBase.cloneTypeAsInstance(
+          type,
+          /* cache */
+          includeSubclasses
+        );
         newInstance.flags &= ~8;
         if (includeSubclasses) {
           newInstance.includeSubclasses = true;
@@ -28448,8 +28466,16 @@ var require_types = __commonJS({
         return newInstance;
       }
       ClassType2.cloneAsInstance = cloneAsInstance;
-      function cloneAsInstantiable(objectType) {
-        return TypeBase.cloneTypeAsInstantiable(objectType);
+      function cloneAsInstantiable(type) {
+        var _a;
+        if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstantiableType) {
+          return type.cached.typeBaseInstantiableType;
+        }
+        return TypeBase.cloneTypeAsInstantiable(
+          type,
+          /* cache */
+          true
+        );
       }
       ClassType2.cloneAsInstantiable = cloneAsInstantiable;
       function cloneForSpecialization(classType, typeArguments, isTypeArgumentExplicit, includeSubclasses = false, tupleTypeArguments, isEmptyContainer) {
@@ -28880,7 +28906,7 @@ var require_types = __commonJS({
         var _a;
         const newFunction = create(type.details.name, type.details.fullName, type.details.moduleName, type.details.flags, type.flags, type.details.docString);
         newFunction.details = { ...type.details };
-        newFunction.boundToType = boundToType;
+        newFunction.boundToType = boundToType !== null && boundToType !== void 0 ? boundToType : type.boundToType;
         newFunction.preBoundFlags = newFunction.details.flags;
         if (stripFirstParam) {
           if (type.details.parameters.length > 0) {
@@ -28907,18 +28933,34 @@ var require_types = __commonJS({
           };
         }
         newFunction.inferredReturnType = type.inferredReturnType;
-        newFunction.boundTypeVarScopeId = boundTypeVarScopeId;
+        newFunction.boundTypeVarScopeId = boundTypeVarScopeId !== null && boundTypeVarScopeId !== void 0 ? boundTypeVarScopeId : type.boundTypeVarScopeId;
         return newFunction;
       }
       FunctionType2.clone = clone;
       function cloneAsInstance(type) {
-        const newInstance = TypeBase.cloneTypeAsInstance(type);
+        var _a;
+        if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstanceType) {
+          return type.cached.typeBaseInstanceType;
+        }
+        const newInstance = TypeBase.cloneTypeAsInstance(
+          type,
+          /* cache */
+          true
+        );
         newInstance.flags &= ~8;
         return newInstance;
       }
       FunctionType2.cloneAsInstance = cloneAsInstance;
       function cloneAsInstantiable(type) {
-        const newInstance = TypeBase.cloneTypeAsInstantiable(type);
+        var _a;
+        if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstantiableType) {
+          return type.cached.typeBaseInstantiableType;
+        }
+        const newInstance = TypeBase.cloneTypeAsInstantiable(
+          type,
+          /* cache */
+          true
+        );
         newInstance.flags &= ~8;
         return newInstance;
       }
@@ -29469,14 +29511,30 @@ var require_types = __commonJS({
       }
       TypeVarType2.createInstantiable = createInstantiable;
       function cloneAsInstance(type) {
+        var _a;
         (0, debug_1.assert)(TypeBase.isInstantiable(type));
-        const newInstance = TypeBase.cloneTypeAsInstance(type);
+        if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstanceType) {
+          return type.cached.typeBaseInstanceType;
+        }
+        const newInstance = TypeBase.cloneTypeAsInstance(
+          type,
+          /* cache */
+          true
+        );
         newInstance.flags &= ~8;
         return newInstance;
       }
       TypeVarType2.cloneAsInstance = cloneAsInstance;
       function cloneAsInstantiable(type) {
-        const newInstance = TypeBase.cloneTypeAsInstantiable(type);
+        var _a;
+        if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstantiableType) {
+          return type.cached.typeBaseInstantiableType;
+        }
+        const newInstance = TypeBase.cloneTypeAsInstantiable(
+          type,
+          /* cache */
+          true
+        );
         newInstance.flags &= ~8;
         return newInstance;
       }
@@ -30675,8 +30733,8 @@ var require_typeUtils = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/analyzer/typeUtils.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.ensureFunctionSignaturesAreUnique = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isUnboundedTupleClass = exports.isTupleClass = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isCallableType = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.getTypeVarScopeIds = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSubtype = exports.sortTypes = exports.mapSubtypes = exports.makeInferenceContext = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.ClassMemberLookupFlags = void 0;
-    exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = exports.requiresSpecialization = exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.removeParamSpecVariadicsFromFunction = exports.removeParamSpecVariadicsFromSignature = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = void 0;
+    exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.ensureFunctionSignaturesAreUnique = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isUnboundedTupleClass = exports.isTupleClass = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isCallableType = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.specializeWithDefaultTypeArgs = exports.getTypeVarScopeIds = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSubtype = exports.sortTypes = exports.mapSubtypes = exports.makeInferenceContext = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.ClassMemberLookupFlags = void 0;
+    exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = exports.requiresSpecialization = exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.removeParamSpecVariadicsFromFunction = exports.removeParamSpecVariadicsFromSignature = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = void 0;
     var collectionUtils_1 = require_collectionUtils();
     var debug_1 = require_debug2();
     var symbol_1 = require_symbol();
@@ -30715,6 +30773,7 @@ var require_typeUtils = __commonJS({
       AssignTypeFlags2[AssignTypeFlags2["SkipSelfClsTypeCheck"] = 256] = "SkipSelfClsTypeCheck";
       AssignTypeFlags2[AssignTypeFlags2["IgnoreTypeVarScope"] = 512] = "IgnoreTypeVarScope";
       AssignTypeFlags2[AssignTypeFlags2["PopulatingExpectedType"] = 1024] = "PopulatingExpectedType";
+      AssignTypeFlags2[AssignTypeFlags2["AllowUnspecifiedTypeArguments"] = 2048] = "AllowUnspecifiedTypeArguments";
     })(AssignTypeFlags = exports.AssignTypeFlags || (exports.AssignTypeFlags = {}));
     var UniqueSignatureTracker = class {
       constructor() {
@@ -31099,20 +31158,38 @@ var require_typeUtils = __commonJS({
     }
     exports.getTypeVarScopeId = getTypeVarScopeId;
     function getTypeVarScopeIds(type) {
+      const scopeIds = [];
       const scopeId = getTypeVarScopeId(type);
-      if (scopeId && (0, types_1.isFunction)(type)) {
-        const scopeIds = [scopeId];
+      if (scopeId) {
+        scopeIds.push(scopeId);
+      }
+      if ((0, types_1.isFunction)(type)) {
         if (type.details.constructorTypeVarScopeId) {
           scopeIds.push(type.details.constructorTypeVarScopeId);
         }
         if (type.details.paramSpecTypeVarScopeId) {
           scopeIds.push(type.details.paramSpecTypeVarScopeId);
         }
-        return scopeIds;
       }
-      return scopeId;
+      return scopeIds;
     }
     exports.getTypeVarScopeIds = getTypeVarScopeIds;
+    function specializeWithDefaultTypeArgs(type) {
+      if (type.details.typeParameters.length === 0 || type.typeArguments) {
+        return type;
+      }
+      return types_1.ClassType.cloneForSpecialization(
+        type,
+        type.details.typeParameters.map((param) => {
+          var _a;
+          return (_a = param.details.defaultType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+        }),
+        /* isTypeArgumentExplicit */
+        false,
+        !!type.includeSubclasses
+      );
+    }
+    exports.specializeWithDefaultTypeArgs = specializeWithDefaultTypeArgs;
     function getSpecializedTupleType(type) {
       let classType;
       if ((0, types_1.isInstantiableClass)(type)) {
@@ -32041,10 +32118,12 @@ var require_typeUtils = __commonJS({
       if (type.typeAliasInfo && type !== result) {
         result = types_1.TypeBase.cloneForTypeAlias(result, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
       }
-      if (!type.cached) {
-        type.cached = {};
+      if (type !== result) {
+        if (!type.cached) {
+          type.cached = {};
+        }
+        type.cached.instantiableType = result;
       }
-      type.cached.instantiableType = result;
       return result;
     }
     exports.convertToInstantiable = convertToInstantiable;
@@ -40538,6 +40617,7 @@ var require_parameterUtils = __commonJS({
               }, index, specializedParamType);
             });
             result.hasUnpackedTypedDict = true;
+            result.unpackedKwargsTypedDictType = paramType;
           } else if (param.name) {
             if (result.kwargsIndex === void 0) {
               result.kwargsIndex = result.params.length;
@@ -40583,7 +40663,7 @@ var require_typeEvaluatorTypes = __commonJS({
       EvaluatorFlags2[EvaluatorFlags2["DisallowFinal"] = 16] = "DisallowFinal";
       EvaluatorFlags2[EvaluatorFlags2["DisallowParamSpec"] = 32] = "DisallowParamSpec";
       EvaluatorFlags2[EvaluatorFlags2["DisallowTypeVarTuple"] = 64] = "DisallowTypeVarTuple";
-      EvaluatorFlags2[EvaluatorFlags2["ExpectingType"] = 128] = "ExpectingType";
+      EvaluatorFlags2[EvaluatorFlags2["ExpectingInstantiableType"] = 128] = "ExpectingInstantiableType";
       EvaluatorFlags2[EvaluatorFlags2["ExpectingTypeAnnotation"] = 256] = "ExpectingTypeAnnotation";
       EvaluatorFlags2[EvaluatorFlags2["AllowMissingTypeArgs"] = 512] = "AllowMissingTypeArgs";
       EvaluatorFlags2[EvaluatorFlags2["AllowGenericClassType"] = 1024] = "AllowGenericClassType";
@@ -40858,6 +40938,11 @@ var require_constraintSolver = __commonJS({
       let newWideTypeBound = curWideTypeBound;
       const diagAddendum = diag ? new diagnostic_1.DiagnosticAddendum() : void 0;
       let adjSrcType = srcType;
+      if ((flags & 2048) === 0) {
+        if ((0, types_1.isClass)(adjSrcType) && adjSrcType.includeSubclasses) {
+          adjSrcType = (0, typeUtils_1.specializeWithDefaultTypeArgs)(adjSrcType);
+        }
+      }
       if (types_1.TypeBase.isInstantiable(destType)) {
         if ((0, typeUtils_1.isEffectivelyInstantiable)(adjSrcType)) {
           adjSrcType = (0, typeUtils_1.convertToInstance)(
@@ -41293,6 +41378,10 @@ var require_constraintSolver = __commonJS({
               }
               if (typeArgValue) {
                 const variance = types_1.TypeVarType.getVariance(typeVar);
+                if (typeVarContext.getPrimarySignature().getTypeVarType(targetTypeVar)) {
+                  isResultValid = false;
+                  typeArgValue = types_1.UnknownType.create();
+                }
                 typeVarContext.setTypeVarType(
                   targetTypeVar,
                   variance === 3 ? void 0 : typeArgValue,
@@ -41666,14 +41755,14 @@ var require_typedDicts = __commonJS({
             let returnType;
             if (isEntryRequired) {
               defaultParamType = types_1.AnyType.create();
-              returnType = valueType !== null && valueType !== void 0 ? valueType : types_1.AnyType.create();
+              returnType = valueType;
             } else {
-              defaultParamType = defaultTypeMatchesField && valueType ? valueType : defaultTypeVar;
-              if (valueType) {
-                returnType = defaultTypeMatchesField ? valueType : (0, types_1.combineTypes)([valueType, defaultTypeVar]);
+              if (defaultTypeMatchesField) {
+                defaultParamType = valueType;
               } else {
-                returnType = defaultTypeVar;
+                defaultParamType = (0, types_1.combineTypes)([valueType, defaultTypeVar]);
               }
+              returnType = defaultParamType;
             }
             types_1.FunctionType.addParameter(getOverload, {
               category: 0,
@@ -41683,7 +41772,7 @@ var require_typedDicts = __commonJS({
             });
             getOverload.details.declaredReturnType = returnType;
           } else {
-            getOverload.details.declaredReturnType = isEntryRequired ? valueType : (0, types_1.combineTypes)([valueType !== null && valueType !== void 0 ? valueType : types_1.AnyType.create(), types_1.NoneType.createInstance()]);
+            getOverload.details.declaredReturnType = isEntryRequired ? valueType : (0, types_1.combineTypes)([valueType, types_1.NoneType.createInstance()]);
           }
           return getOverload;
         }, createPopMethods = function(keyType, valueType) {
@@ -41802,16 +41891,6 @@ var require_typedDicts = __commonJS({
               true
             ));
           } else {
-            getOverloads.push(createGetMethod(
-              nameLiteralType,
-              entry.valueType,
-              /* includeDefault */
-              true,
-              /* isEntryRequired */
-              false,
-              /* defaultTypeMatchesField */
-              true
-            ));
             getOverloads.push(createGetMethod(
               nameLiteralType,
               entry.valueType,
@@ -41845,7 +41924,7 @@ var require_typedDicts = __commonJS({
             getOverloads.push(createGetMethod(
               literalStringInstance,
               /* valueType */
-              void 0,
+              types_1.UnknownType.create(),
               /* includeDefault */
               true
             ));
@@ -42710,7 +42789,7 @@ var require_typeGuards = __commonJS({
               const isInstanceCheck = callType.details.builtInName === "isinstance";
               const arg1TypeResult = evaluator.getTypeOfExpression(
                 arg1Expr,
-                8 | 32 | 64
+                512 | 8 | 32 | 64
                 /* DisallowTypeVarTuple */
               );
               const arg1Type = arg1TypeResult.type;
@@ -43134,31 +43213,33 @@ var require_typeGuards = __commonJS({
               if (filterIsSuperclass) {
                 filteredTypes.push((0, typeUtils_1.addConditionToType)(varType, constraints));
               } else if (filterIsSubclass) {
-                let specializedFilterType = filterType;
-                if ((0, types_1.isClass)(filterType)) {
-                  if (types_1.ClassType.isSpecialBuiltIn(filterType) || filterType.details.typeParameters.length > 0) {
-                    const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(filterType));
-                    const unspecializedFilterType = types_1.ClassType.cloneForSpecialization(
-                      filterType,
-                      /* typeArguments */
-                      void 0,
-                      /* isTypeArgumentExplicit */
-                      false
-                    );
-                    if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(
-                      evaluator,
-                      unspecializedFilterType,
-                      varType,
-                      typeVarContext,
-                      /* liveTypeVarScopes */
-                      void 0,
-                      errorNode.start
-                    )) {
-                      specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, { unknownIfNotFound: true });
+                if (evaluator.assignType(varType, filterType)) {
+                  let specializedFilterType = filterType;
+                  if ((0, types_1.isClass)(filterType)) {
+                    if (types_1.ClassType.isSpecialBuiltIn(filterType) || filterType.details.typeParameters.length > 0) {
+                      const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(filterType));
+                      const unspecializedFilterType = types_1.ClassType.cloneForSpecialization(
+                        filterType,
+                        /* typeArguments */
+                        void 0,
+                        /* isTypeArgumentExplicit */
+                        false
+                      );
+                      if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(
+                        evaluator,
+                        unspecializedFilterType,
+                        varType,
+                        typeVarContext,
+                        /* liveTypeVarScopes */
+                        void 0,
+                        errorNode.start
+                      )) {
+                        specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, { unknownIfNotFound: true });
+                      }
                     }
                   }
+                  filteredTypes.push((0, typeUtils_1.addConditionToType)(specializedFilterType, constraints));
                 }
-                filteredTypes.push((0, typeUtils_1.addConditionToType)(specializedFilterType, constraints));
               } else if (allowIntersections && !types_1.ClassType.isFinal(varType) && !types_1.ClassType.isFinal(concreteFilterType)) {
                 const className = `<subclass of ${varType.details.name} and ${concreteFilterType.details.name}>`;
                 const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
@@ -45020,7 +45101,7 @@ var require_codeFlowUtils = __commonJS({
         if (f.flags & (codeFlowTypes_1.FlowFlags.LoopLabel | codeFlowTypes_1.FlowFlags.BranchLabel)) {
           return f.antecedents;
         }
-        if (f.flags & (codeFlowTypes_1.FlowFlags.Assignment | codeFlowTypes_1.FlowFlags.VariableAnnotation | codeFlowTypes_1.FlowFlags.WildcardImport | codeFlowTypes_1.FlowFlags.TrueCondition | codeFlowTypes_1.FlowFlags.FalseCondition | codeFlowTypes_1.FlowFlags.NarrowForPattern | codeFlowTypes_1.FlowFlags.ExhaustedMatch | codeFlowTypes_1.FlowFlags.Call | codeFlowTypes_1.FlowFlags.PreFinallyGate | codeFlowTypes_1.FlowFlags.PostFinally)) {
+        if (f.flags & (codeFlowTypes_1.FlowFlags.Assignment | codeFlowTypes_1.FlowFlags.VariableAnnotation | codeFlowTypes_1.FlowFlags.WildcardImport | codeFlowTypes_1.FlowFlags.TrueCondition | codeFlowTypes_1.FlowFlags.FalseCondition | codeFlowTypes_1.FlowFlags.TrueNeverCondition | codeFlowTypes_1.FlowFlags.FalseNeverCondition | codeFlowTypes_1.FlowFlags.NarrowForPattern | codeFlowTypes_1.FlowFlags.ExhaustedMatch | codeFlowTypes_1.FlowFlags.Call | codeFlowTypes_1.FlowFlags.PreFinallyGate | codeFlowTypes_1.FlowFlags.PostFinally)) {
           const typedFlowNode = f;
           return [typedFlowNode.antecedent];
         }
@@ -45819,19 +45900,27 @@ var require_codeFlowEngine = __commonJS({
               let sawPending = false;
               let isProvenReachable = reference === void 0 && ((_a = cacheEntry.incompleteSubtypes) === null || _a === void 0 ? void 0 : _a.some((subtype) => subtype.type !== void 0));
               let firstAntecedentTypeIsIncomplete = false;
+              let firstAntecedentTypeIsPending = false;
               loopNode.antecedents.forEach((antecedent, index) => {
                 var _a2, _b;
                 if (reference === void 0 && isProvenReachable) {
                   return;
                 }
+                if (firstAntecedentTypeIsPending && index > 0) {
+                  return;
+                }
                 cacheEntry = getCacheEntry(loopNode);
                 if (cacheEntry.incompleteSubtypes && index < cacheEntry.incompleteSubtypes.length && cacheEntry.incompleteSubtypes[index].isPending) {
-                  sawIncomplete = true;
-                  sawPending = true;
-                  return;
+                  if (index === 0) {
+                    firstAntecedentTypeIsPending = true;
+                  } else {
+                    sawIncomplete = true;
+                    sawPending = true;
+                    return;
+                  }
                 }
                 const subtypeEntry = cacheEntry.incompleteSubtypes !== void 0 && index < cacheEntry.incompleteSubtypes.length ? cacheEntry.incompleteSubtypes[index] : void 0;
-                if (subtypeEntry === void 0 || !(subtypeEntry === null || subtypeEntry === void 0 ? void 0 : subtypeEntry.isPending) && (subtypeEntry === null || subtypeEntry === void 0 ? void 0 : subtypeEntry.isIncomplete)) {
+                if (subtypeEntry === void 0 || !(subtypeEntry === null || subtypeEntry === void 0 ? void 0 : subtypeEntry.isPending) && (subtypeEntry === null || subtypeEntry === void 0 ? void 0 : subtypeEntry.isIncomplete) || index === 0) {
                   const entryEvaluationCount = subtypeEntry === void 0 ? 0 : subtypeEntry.evaluationCount;
                   cacheEntry = setIncompleteSubtype(
                     loopNode,
@@ -45910,6 +45999,9 @@ var require_codeFlowEngine = __commonJS({
                 if (sawPending || sawIncomplete) {
                   return { type: effectiveType, isIncomplete: reportIncomplete };
                 }
+                if (firstAntecedentTypeIsPending) {
+                  return { type: effectiveType, isIncomplete: true };
+                }
                 return setCacheEntry(
                   loopNode,
                   effectiveType,
@@ -47070,9 +47162,7 @@ var require_constructors = __commonJS({
         /* SkipObjectBaseClass */
       );
       if (initInfo) {
-        const initType = evaluator.getTypeOfMember(initInfo);
-        const objectType = types_1.ClassType.cloneAsInstance(classType);
-        const convertInitToConstructor = (initSubtype) => {
+        let convertInitToConstructor = function(initSubtype) {
           let constructorFunction2 = evaluator.bindFunctionToClassOrObject(
             objectType,
             initSubtype,
@@ -47085,6 +47175,7 @@ var require_constructors = __commonJS({
           if (constructorFunction2) {
             constructorFunction2 = types_1.FunctionType.clone(constructorFunction2);
             constructorFunction2.details.declaredReturnType = objectType;
+            constructorFunction2.details.typeVarScopeId = initSubtype.details.typeVarScopeId;
             if (constructorFunction2.specializedTypes) {
               constructorFunction2.specializedTypes.returnType = objectType;
             }
@@ -47092,9 +47183,12 @@ var require_constructors = __commonJS({
               constructorFunction2.details.docString = classType.details.docString;
             }
             constructorFunction2.details.flags &= ~4;
+            constructorFunction2.details.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
           }
           return constructorFunction2;
         };
+        const initType = evaluator.getTypeOfMember(initInfo);
+        const objectType = types_1.ClassType.cloneAsInstance(classType);
         if ((0, types_1.isFunction)(initType)) {
           return convertInitToConstructor(initType);
         } else if ((0, types_1.isOverloadedFunction)(initType)) {
@@ -47135,10 +47229,12 @@ var require_constructors = __commonJS({
           );
           if (constructorFunction2) {
             constructorFunction2 = types_1.FunctionType.clone(constructorFunction2);
+            constructorFunction2.details.typeVarScopeId = newSubtype.details.typeVarScopeId;
             if (!constructorFunction2.details.docString && classType.details.docString) {
               constructorFunction2.details.docString = classType.details.docString;
             }
             constructorFunction2.details.flags &= ~(4 | 1);
+            constructorFunction2.details.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
           }
           return constructorFunction2;
         };
@@ -47574,6 +47670,7 @@ var require_dataClasses = __commonJS({
     var diagnosticRules_1 = require_diagnosticRules();
     var localize_1 = require_localize();
     var AnalyzerNodeInfo = __importStar(require_analyzerNodeInfo());
+    var analyzerNodeInfo_1 = require_analyzerNodeInfo();
     var constructors_1 = require_constructors();
     var namedTuples_1 = require_namedTuples();
     var parseTreeUtils_1 = require_parseTreeUtils();
@@ -47888,7 +47985,9 @@ var require_dataClasses = __commonJS({
               }
               effectiveType = transformDescriptorType(evaluator, effectiveType);
               if (entry.converter) {
+                const fieldType = effectiveType;
                 effectiveType = getConverterInputType(evaluator, entry.converter, effectiveType, entry.name);
+                symbolTable.set(entry.name, getDescriptorForConverterField(evaluator, node, entry.converter, entry.name, fieldType, effectiveType));
               }
               const effectiveName = entry.alias || entry.name;
               if (!entry.alias && entry.nameNode && (0, symbolNameUtils_1.isPrivateName)(entry.nameNode.value)) {
@@ -48078,6 +48177,75 @@ var require_dataClasses = __commonJS({
       }
       return void 0;
     }
+    function getDescriptorForConverterField(evaluator, dataclassNode, converterNode, fieldName, getType, setType) {
+      const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(dataclassNode);
+      const typeMetaclass = evaluator.getBuiltInType(dataclassNode, "type");
+      const descriptorName = `__converterDescriptor_${fieldName}`;
+      const descriptorClass = types_1.ClassType.createInstantiable(
+        descriptorName,
+        (0, parseTreeUtils_1.getClassFullName)(converterNode, fileInfo.moduleName, descriptorName),
+        fileInfo.moduleName,
+        fileInfo.filePath,
+        0,
+        (0, parseTreeUtils_1.getTypeSourceId)(converterNode),
+        /* declaredMetaclass */
+        void 0,
+        (0, types_1.isInstantiableClass)(typeMetaclass) ? typeMetaclass : types_1.UnknownType.create()
+      );
+      descriptorClass.details.baseClasses.push(evaluator.getBuiltInType(dataclassNode, "object"));
+      (0, typeUtils_1.computeMroLinearization)(descriptorClass);
+      const fields = descriptorClass.details.fields;
+      const selfType = (0, typeUtils_1.synthesizeTypeVarForSelfCls)(
+        descriptorClass,
+        /* isClsParam */
+        false
+      );
+      const setFunction = types_1.FunctionType.createSynthesizedInstance("__set__");
+      types_1.FunctionType.addParameter(setFunction, {
+        category: 0,
+        name: "self",
+        type: selfType,
+        hasDeclaredType: true
+      });
+      types_1.FunctionType.addParameter(setFunction, {
+        category: 0,
+        name: "obj",
+        type: types_1.AnyType.create(),
+        hasDeclaredType: true
+      });
+      types_1.FunctionType.addParameter(setFunction, {
+        category: 0,
+        name: "value",
+        type: setType,
+        hasDeclaredType: true
+      });
+      setFunction.details.declaredReturnType = types_1.NoneType.createInstance();
+      const setSymbol = symbol_1.Symbol.createWithType(4, setFunction);
+      fields.set("__set__", setSymbol);
+      const getFunction = types_1.FunctionType.createSynthesizedInstance("__get__");
+      types_1.FunctionType.addParameter(getFunction, {
+        category: 0,
+        name: "self",
+        type: selfType,
+        hasDeclaredType: true
+      });
+      types_1.FunctionType.addParameter(getFunction, {
+        category: 0,
+        name: "obj",
+        type: types_1.AnyType.create(),
+        hasDeclaredType: true
+      });
+      types_1.FunctionType.addParameter(getFunction, {
+        category: 0,
+        name: "objtype",
+        type: types_1.AnyType.create(),
+        hasDeclaredType: true
+      });
+      getFunction.details.declaredReturnType = getType;
+      const getSymbol = symbol_1.Symbol.createWithType(4, getFunction);
+      fields.set("__get__", getSymbol);
+      return symbol_1.Symbol.createWithType(4, types_1.ClassType.cloneAsInstance(descriptorClass));
+    }
     function transformDescriptorType(evaluator, type) {
       if (!(0, types_1.isClassInstance)(type)) {
         return type;
@@ -48364,6 +48532,783 @@ var require_dataClasses = __commonJS({
   }
 });
 
+// node_modules/@zzzen/pyright-internal/dist/analyzer/properties.js
+var require_properties = __commonJS({
+  "node_modules/@zzzen/pyright-internal/dist/analyzer/properties.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.assignProperty = exports.clonePropertyWithDeleter = exports.clonePropertyWithSetter = exports.createProperty = exports.validatePropertyMethod = void 0;
+    var diagnostic_1 = require_diagnostic();
+    var diagnosticRules_1 = require_diagnosticRules();
+    var localize_1 = require_localize();
+    var analyzerNodeInfo_1 = require_analyzerNodeInfo();
+    var parseTreeUtils_1 = require_parseTreeUtils();
+    var symbol_1 = require_symbol();
+    var types_1 = require_types();
+    var typeUtils_1 = require_typeUtils();
+    function validatePropertyMethod(evaluator, method2, errorNode) {
+      if (types_1.FunctionType.isStaticMethod(method2)) {
+        evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.propertyStaticMethod(), errorNode);
+      }
+    }
+    exports.validatePropertyMethod = validatePropertyMethod;
+    function createProperty(evaluator, decoratorNode, decoratorType, fget) {
+      const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(decoratorNode);
+      const typeMetaclass = evaluator.getBuiltInType(decoratorNode, "type");
+      const typeSourceId = types_1.ClassType.isBuiltIn(decoratorType, "property") ? (0, parseTreeUtils_1.getTypeSourceId)(decoratorNode) : decoratorType.details.typeSourceId;
+      const propertyClass = types_1.ClassType.createInstantiable(
+        decoratorType.details.name,
+        (0, parseTreeUtils_1.getClassFullName)(decoratorNode, fileInfo.moduleName, `__property_${fget.details.name}`),
+        fileInfo.moduleName,
+        fileInfo.filePath,
+        2048 | 1,
+        typeSourceId,
+        /* declaredMetaclass */
+        void 0,
+        (0, types_1.isInstantiableClass)(typeMetaclass) ? typeMetaclass : types_1.UnknownType.create()
+      );
+      propertyClass.details.typeVarScopeId = decoratorType.details.typeVarScopeId;
+      const objectType = evaluator.getBuiltInType(decoratorNode, "object");
+      propertyClass.details.baseClasses.push((0, types_1.isInstantiableClass)(objectType) ? objectType : types_1.UnknownType.create());
+      (0, typeUtils_1.computeMroLinearization)(propertyClass);
+      const fields = propertyClass.details.fields;
+      decoratorType.details.fields.forEach((symbol, name) => {
+        const ignoredMethods = ["__get__", "__set__", "__delete__", "fget", "fset", "fdel"];
+        if (!symbol.isIgnoredForProtocolMatch()) {
+          if (!ignoredMethods.some((m) => m === name)) {
+            fields.set(name, symbol);
+          }
+        }
+      });
+      const propertyObject = types_1.ClassType.cloneAsInstance(propertyClass);
+      propertyClass.isAsymmetricDescriptor = false;
+      updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
+      const fgetSymbol = symbol_1.Symbol.createWithType(4, types_1.FunctionType.cloneWithNewFlags(
+        fget,
+        fget.details.flags | 4
+        /* StaticMethod */
+      ));
+      fields.set("fget", fgetSymbol);
+      if (types_1.FunctionType.isClassMethod(fget)) {
+        propertyClass.details.flags |= 4194304;
+      }
+      addGetMethodToPropertySymbolTable(evaluator, propertyObject, fget);
+      addDecoratorMethodsToPropertySymbolTable(propertyObject);
+      return propertyObject;
+    }
+    exports.createProperty = createProperty;
+    function clonePropertyWithSetter(evaluator, prop, fset, errorNode) {
+      if (!(0, typeUtils_1.isProperty)(prop)) {
+        return prop;
+      }
+      const classType = prop;
+      const flagsToClone = classType.details.flags;
+      let isAsymmetricDescriptor = !!classType.isAsymmetricDescriptor;
+      const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
+      if (errorNode.parameters.length >= 2) {
+        const typeAnnotation = (0, parseTreeUtils_1.getTypeAnnotationForParameter)(errorNode, 1);
+        if (typeAnnotation) {
+          const fgetType = evaluator.getGetterTypeFromProperty(
+            classType,
+            /* inferTypeIfNeeded */
+            false
+          );
+          if (fgetType && !(0, types_1.isAnyOrUnknown)(fgetType)) {
+            const fsetType = evaluator.getTypeOfAnnotation(typeAnnotation, {
+              associateTypeVarsWithScope: true
+            });
+            if (fileInfo.diagnosticRuleSet.reportPropertyTypeMismatch !== "none") {
+              const diag = new diagnostic_1.DiagnosticAddendum();
+              if (!evaluator.assignType(fgetType, fsetType, diag)) {
+                evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportPropertyTypeMismatch, diagnosticRules_1.DiagnosticRule.reportPropertyTypeMismatch, localize_1.Localizer.Diagnostic.setterGetterTypeMismatch() + diag.getString(), typeAnnotation);
+              }
+            }
+            if (!(0, types_1.isTypeSame)(fgetType, fsetType)) {
+              isAsymmetricDescriptor = true;
+            }
+          }
+        }
+      }
+      const propertyClass = types_1.ClassType.createInstantiable(classType.details.name, classType.details.fullName, classType.details.moduleName, (0, analyzerNodeInfo_1.getFileInfo)(errorNode).filePath, flagsToClone, classType.details.typeSourceId, classType.details.declaredMetaclass, classType.details.effectiveMetaclass);
+      propertyClass.details.typeVarScopeId = classType.details.typeVarScopeId;
+      const objectType = evaluator.getBuiltInType(errorNode, "object");
+      propertyClass.details.baseClasses.push((0, types_1.isInstantiableClass)(objectType) ? objectType : types_1.UnknownType.create());
+      (0, typeUtils_1.computeMroLinearization)(propertyClass);
+      propertyClass.isAsymmetricDescriptor = isAsymmetricDescriptor;
+      const propertyObject = types_1.ClassType.cloneAsInstance(propertyClass);
+      const fields = propertyClass.details.fields;
+      classType.details.fields.forEach((symbol, name) => {
+        if (!symbol.isIgnoredForProtocolMatch()) {
+          fields.set(name, symbol);
+        }
+      });
+      updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
+      const fsetSymbol = symbol_1.Symbol.createWithType(4, types_1.FunctionType.cloneWithNewFlags(
+        fset,
+        fset.details.flags | 4
+        /* StaticMethod */
+      ));
+      fields.set("fset", fsetSymbol);
+      addSetMethodToPropertySymbolTable(evaluator, propertyObject, fset);
+      addDecoratorMethodsToPropertySymbolTable(propertyObject);
+      return propertyObject;
+    }
+    exports.clonePropertyWithSetter = clonePropertyWithSetter;
+    function clonePropertyWithDeleter(evaluator, prop, fdel, errorNode) {
+      var _a;
+      if (!(0, typeUtils_1.isProperty)(prop)) {
+        return prop;
+      }
+      const classType = prop;
+      const propertyClass = types_1.ClassType.createInstantiable(classType.details.name, classType.details.fullName, classType.details.moduleName, (0, analyzerNodeInfo_1.getFileInfo)(errorNode).filePath, classType.details.flags, classType.details.typeSourceId, classType.details.declaredMetaclass, classType.details.effectiveMetaclass);
+      propertyClass.details.typeVarScopeId = classType.details.typeVarScopeId;
+      const objectType = evaluator.getBuiltInType(errorNode, "object");
+      propertyClass.details.baseClasses.push((0, types_1.isInstantiableClass)(objectType) ? objectType : types_1.UnknownType.create());
+      (0, typeUtils_1.computeMroLinearization)(propertyClass);
+      const propertyObject = types_1.ClassType.cloneAsInstance(propertyClass);
+      propertyClass.isAsymmetricDescriptor = (_a = classType.isAsymmetricDescriptor) !== null && _a !== void 0 ? _a : false;
+      const fields = propertyClass.details.fields;
+      classType.details.fields.forEach((symbol, name) => {
+        if (!symbol.isIgnoredForProtocolMatch()) {
+          fields.set(name, symbol);
+        }
+      });
+      updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
+      const fdelSymbol = symbol_1.Symbol.createWithType(4, types_1.FunctionType.cloneWithNewFlags(
+        fdel,
+        fdel.details.flags | 4
+        /* StaticMethod */
+      ));
+      fields.set("fdel", fdelSymbol);
+      addDelMethodToPropertySymbolTable(evaluator, propertyObject, fdel);
+      addDecoratorMethodsToPropertySymbolTable(propertyObject);
+      return propertyObject;
+    }
+    exports.clonePropertyWithDeleter = clonePropertyWithDeleter;
+    function addGetMethodToPropertySymbolTable(evaluator, propertyObject, fget) {
+      const fields = propertyObject.details.fields;
+      const getFunction1 = types_1.FunctionType.createSynthesizedInstance(
+        "__get__",
+        256
+        /* Overloaded */
+      );
+      types_1.FunctionType.addParameter(getFunction1, {
+        category: 0,
+        name: "self",
+        type: types_1.AnyType.create(),
+        hasDeclaredType: true
+      });
+      types_1.FunctionType.addParameter(getFunction1, {
+        category: 0,
+        name: "obj",
+        type: types_1.NoneType.createInstance(),
+        hasDeclaredType: true
+      });
+      types_1.FunctionType.addParameter(getFunction1, {
+        category: 0,
+        name: "objtype",
+        type: types_1.AnyType.create(),
+        hasDeclaredType: true,
+        hasDefault: true,
+        defaultType: types_1.AnyType.create()
+      });
+      getFunction1.details.declaredReturnType = types_1.FunctionType.isClassMethod(fget) ? types_1.FunctionType.getSpecializedReturnType(fget) : propertyObject;
+      getFunction1.details.declaration = fget.details.declaration;
+      getFunction1.details.typeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(fget);
+      const getFunction2 = types_1.FunctionType.createSynthesizedInstance(
+        "__get__",
+        256
+        /* Overloaded */
+      );
+      types_1.FunctionType.addParameter(getFunction2, {
+        category: 0,
+        name: "self",
+        type: types_1.AnyType.create(),
+        hasDeclaredType: true
+      });
+      const objType = fget.details.parameters.length > 0 ? fget.details.parameters[0].type : types_1.AnyType.create();
+      types_1.FunctionType.addParameter(getFunction2, {
+        category: 0,
+        name: "obj",
+        type: objType,
+        hasDeclaredType: true
+      });
+      types_1.FunctionType.addParameter(getFunction2, {
+        category: 0,
+        name: "objtype",
+        type: types_1.AnyType.create(),
+        hasDeclaredType: true,
+        hasDefault: true,
+        defaultType: types_1.AnyType.create()
+      });
+      getFunction2.details.declaredReturnType = types_1.FunctionType.getSpecializedReturnType(fget);
+      getFunction2.details.declaration = fget.details.declaration;
+      getFunction2.details.typeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(fget);
+      const getFunctionOverload = types_1.OverloadedFunctionType.create([getFunction2, getFunction1]);
+      const getSymbol = symbol_1.Symbol.createWithType(4, getFunctionOverload);
+      fields.set("__get__", getSymbol);
+    }
+    function addSetMethodToPropertySymbolTable(evaluator, propertyObject, fset) {
+      const fields = propertyObject.details.fields;
+      const setFunction = types_1.FunctionType.createSynthesizedInstance("__set__");
+      types_1.FunctionType.addParameter(setFunction, {
+        category: 0,
+        name: "self",
+        type: types_1.AnyType.create(),
+        hasDeclaredType: true
+      });
+      let objType = fset.details.parameters.length > 0 ? fset.details.parameters[0].type : types_1.AnyType.create();
+      if ((0, types_1.isTypeVar)(objType) && objType.details.isSynthesizedSelf) {
+        objType = evaluator.makeTopLevelTypeVarsConcrete(objType);
+      }
+      types_1.FunctionType.addParameter(setFunction, {
+        category: 0,
+        name: "obj",
+        type: (0, types_1.combineTypes)([objType, types_1.NoneType.createInstance()]),
+        hasDeclaredType: true
+      });
+      setFunction.details.declaredReturnType = types_1.NoneType.createInstance();
+      setFunction.details.typeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(fset);
+      let setParamType = types_1.UnknownType.create();
+      if (fset.details.parameters.length >= 2 && fset.details.parameters[1].category === 0 && fset.details.parameters[1].name) {
+        setParamType = fset.details.parameters[1].type;
+      }
+      types_1.FunctionType.addParameter(setFunction, {
+        category: 0,
+        name: "value",
+        type: setParamType,
+        hasDeclaredType: true
+      });
+      const setSymbol = symbol_1.Symbol.createWithType(4, setFunction);
+      fields.set("__set__", setSymbol);
+    }
+    function addDelMethodToPropertySymbolTable(evaluator, propertyObject, fdel) {
+      const fields = propertyObject.details.fields;
+      const delFunction = types_1.FunctionType.createSynthesizedInstance("__delete__");
+      types_1.FunctionType.addParameter(delFunction, {
+        category: 0,
+        name: "self",
+        type: types_1.AnyType.create(),
+        hasDeclaredType: true
+      });
+      delFunction.details.typeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(fdel);
+      let objType = fdel.details.parameters.length > 0 ? fdel.details.parameters[0].type : types_1.AnyType.create();
+      if ((0, types_1.isTypeVar)(objType) && objType.details.isSynthesizedSelf) {
+        objType = evaluator.makeTopLevelTypeVarsConcrete(objType);
+      }
+      types_1.FunctionType.addParameter(delFunction, {
+        category: 0,
+        name: "obj",
+        type: (0, types_1.combineTypes)([objType, types_1.NoneType.createInstance()]),
+        hasDeclaredType: true
+      });
+      delFunction.details.declaredReturnType = types_1.NoneType.createInstance();
+      const delSymbol = symbol_1.Symbol.createWithType(4, delFunction);
+      fields.set("__delete__", delSymbol);
+    }
+    function updateGetSetDelMethodForClonedProperty(evaluator, propertyObject) {
+      const fields = propertyObject.details.fields;
+      const fgetSymbol = fields.get("fget");
+      const fgetType = fgetSymbol === null || fgetSymbol === void 0 ? void 0 : fgetSymbol.getSynthesizedType();
+      if (fgetType && (0, types_1.isFunction)(fgetType)) {
+        addGetMethodToPropertySymbolTable(evaluator, propertyObject, fgetType);
+      }
+      const fsetSymbol = fields.get("fset");
+      const fsetType = fsetSymbol === null || fsetSymbol === void 0 ? void 0 : fsetSymbol.getSynthesizedType();
+      if (fsetType && (0, types_1.isFunction)(fsetType)) {
+        addSetMethodToPropertySymbolTable(evaluator, propertyObject, fsetType);
+      }
+      const fdelSymbol = fields.get("fdel");
+      const fdelType = fdelSymbol === null || fdelSymbol === void 0 ? void 0 : fdelSymbol.getSynthesizedType();
+      if (fdelType && (0, types_1.isFunction)(fdelType)) {
+        addDelMethodToPropertySymbolTable(evaluator, propertyObject, fdelType);
+      }
+    }
+    function addDecoratorMethodsToPropertySymbolTable(propertyObject) {
+      const fields = propertyObject.details.fields;
+      ["getter", "setter", "deleter"].forEach((accessorName) => {
+        const accessorFunction = types_1.FunctionType.createSynthesizedInstance(accessorName);
+        types_1.FunctionType.addParameter(accessorFunction, {
+          category: 0,
+          name: "self",
+          type: types_1.AnyType.create(),
+          hasDeclaredType: true
+        });
+        types_1.FunctionType.addParameter(accessorFunction, {
+          category: 0,
+          name: "accessor",
+          type: types_1.AnyType.create(),
+          hasDeclaredType: true
+        });
+        accessorFunction.details.declaredReturnType = propertyObject;
+        const accessorSymbol = symbol_1.Symbol.createWithType(4, accessorFunction);
+        fields.set(accessorName, accessorSymbol);
+      });
+    }
+    function assignProperty(evaluator, destPropertyType, srcPropertyType, destClass, srcClass, diag, typeVarContext, selfTypeVarContext, recursionCount = 0) {
+      const srcObjectToBind = types_1.ClassType.cloneAsInstance(srcClass);
+      const destObjectToBind = types_1.ClassType.cloneAsInstance(destClass);
+      let isAssignable = true;
+      const accessors = [
+        {
+          name: "fget",
+          missingDiagMsg: localize_1.Localizer.DiagnosticAddendum.missingGetter,
+          incompatibleDiagMsg: localize_1.Localizer.DiagnosticAddendum.incompatibleGetter
+        },
+        {
+          name: "fset",
+          missingDiagMsg: localize_1.Localizer.DiagnosticAddendum.missingSetter,
+          incompatibleDiagMsg: localize_1.Localizer.DiagnosticAddendum.incompatibleSetter
+        },
+        {
+          name: "fdel",
+          missingDiagMsg: localize_1.Localizer.DiagnosticAddendum.missingDeleter,
+          incompatibleDiagMsg: localize_1.Localizer.DiagnosticAddendum.incompatibleDeleter
+        }
+      ];
+      accessors.forEach((accessorInfo) => {
+        var _a, _b;
+        const destAccessSymbol = destPropertyType.details.fields.get(accessorInfo.name);
+        let destAccessType = destAccessSymbol ? (_a = evaluator.getDeclaredTypeOfSymbol(destAccessSymbol)) === null || _a === void 0 ? void 0 : _a.type : void 0;
+        if (destAccessType && (0, types_1.isFunction)(destAccessType)) {
+          const srcAccessSymbol = srcPropertyType.details.fields.get(accessorInfo.name);
+          let srcAccessType = srcAccessSymbol ? (_b = evaluator.getDeclaredTypeOfSymbol(srcAccessSymbol)) === null || _b === void 0 ? void 0 : _b.type : void 0;
+          if (!srcAccessType || !(0, types_1.isFunction)(srcAccessType)) {
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(accessorInfo.missingDiagMsg());
+            isAssignable = false;
+            return;
+          }
+          evaluator.inferReturnTypeIfNecessary(srcAccessType);
+          srcAccessType = (0, typeUtils_1.partiallySpecializeType)(srcAccessType, srcClass);
+          evaluator.inferReturnTypeIfNecessary(destAccessType);
+          destAccessType = (0, typeUtils_1.partiallySpecializeType)(destAccessType, destClass);
+          if (selfTypeVarContext) {
+            destAccessType = (0, typeUtils_1.applySolvedTypeVars)(destAccessType, selfTypeVarContext);
+          }
+          destAccessType = types_1.FunctionType.cloneWithNewFlags(
+            destAccessType,
+            destAccessType.details.flags & ~4
+            /* StaticMethod */
+          );
+          srcAccessType = types_1.FunctionType.cloneWithNewFlags(
+            srcAccessType,
+            srcAccessType.details.flags & ~4
+            /* StaticMethod */
+          );
+          const boundDestAccessType = evaluator.bindFunctionToClassOrObject(
+            destObjectToBind,
+            destAccessType,
+            /* memberClass */
+            void 0,
+            /* errorNode */
+            void 0,
+            recursionCount
+          );
+          const boundSrcAccessType = evaluator.bindFunctionToClassOrObject(
+            srcObjectToBind,
+            srcAccessType,
+            /* memberClass */
+            void 0,
+            /* errorNode */
+            void 0,
+            recursionCount
+          );
+          if (!boundDestAccessType || !boundSrcAccessType || !evaluator.assignType(
+            boundDestAccessType,
+            boundSrcAccessType,
+            diag,
+            typeVarContext,
+            /* srcTypeVarContext */
+            void 0,
+            0,
+            recursionCount
+          )) {
+            isAssignable = false;
+          }
+        }
+      });
+      return isAssignable;
+    }
+    exports.assignProperty = assignProperty;
+  }
+});
+
+// node_modules/@zzzen/pyright-internal/dist/analyzer/decorators.js
+var require_decorators = __commonJS({
+  "node_modules/@zzzen/pyright-internal/dist/analyzer/decorators.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.addOverloadsToFunctionType = exports.applyClassDecorator = exports.applyFunctionDecorator = exports.getFunctionFlagsFromDecorators = void 0;
+    var collectionUtils_1 = require_collectionUtils();
+    var diagnosticRules_1 = require_diagnosticRules();
+    var localize_1 = require_localize();
+    var analyzerNodeInfo_1 = require_analyzerNodeInfo();
+    var dataClasses_1 = require_dataClasses();
+    var properties_1 = require_properties();
+    var typeUtils_1 = require_typeUtils();
+    var types_1 = require_types();
+    function getFunctionFlagsFromDecorators(evaluator, node, isInClass) {
+      const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(node);
+      let flags = 0;
+      if (isInClass) {
+        if (node.name.value === "__new__") {
+          flags |= 1;
+        }
+        const implicitClassMethods = ["__init_subclass__", "__class_getitem__"];
+        if (implicitClassMethods.some((name) => node.name.value === name)) {
+          flags |= 2;
+        }
+      }
+      for (const decoratorNode of node.decorators) {
+        let evaluatorFlags = fileInfo.isStubFile ? 4 : 0;
+        if (decoratorNode.expression.nodeType !== 9) {
+          evaluatorFlags |= 2;
+        }
+        const decoratorTypeResult = evaluator.getTypeOfExpression(decoratorNode.expression, evaluatorFlags);
+        const decoratorType = decoratorTypeResult.type;
+        if ((0, types_1.isFunction)(decoratorType)) {
+          if (decoratorType.details.builtInName === "abstractmethod") {
+            if (isInClass) {
+              flags |= 8;
+            }
+          } else if (decoratorType.details.builtInName === "final") {
+            flags |= 8192;
+          } else if (decoratorType.details.builtInName === "override") {
+            flags |= 262144;
+          }
+        } else if ((0, types_1.isInstantiableClass)(decoratorType)) {
+          if (types_1.ClassType.isBuiltIn(decoratorType, "staticmethod")) {
+            if (isInClass) {
+              flags |= 4;
+            }
+          } else if (types_1.ClassType.isBuiltIn(decoratorType, "classmethod")) {
+            if (isInClass) {
+              flags |= 2;
+            }
+          }
+        }
+      }
+      return flags;
+    }
+    exports.getFunctionFlagsFromDecorators = getFunctionFlagsFromDecorators;
+    function applyFunctionDecorator(evaluator, inputFunctionType, undecoratedType, decoratorNode, functionNode) {
+      const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(decoratorNode);
+      let evaluatorFlags = fileInfo.isStubFile ? 4 : 0;
+      if (decoratorNode.expression.nodeType !== 9) {
+        evaluatorFlags |= 2;
+      }
+      const decoratorTypeResult = evaluator.getTypeOfExpression(decoratorNode.expression, evaluatorFlags);
+      const decoratorType = decoratorTypeResult.type;
+      if ((0, types_1.isInstantiableClass)(decoratorType) && types_1.ClassType.isSpecialBuiltIn(decoratorType, "overload") || (0, types_1.isFunction)(decoratorType) && decoratorType.details.builtInName === "overload") {
+        if ((0, types_1.isFunction)(inputFunctionType)) {
+          inputFunctionType.details.flags |= 256;
+          undecoratedType.details.flags |= 256;
+          return inputFunctionType;
+        }
+      }
+      if (decoratorNode.expression.nodeType === 9) {
+        const decoratorCallType = evaluator.getTypeOfExpression(
+          decoratorNode.expression.leftExpression,
+          evaluatorFlags | 2
+          /* DoNotSpecialize */
+        ).type;
+        if ((0, types_1.isFunction)(decoratorCallType)) {
+          if (decoratorCallType.details.name === "__dataclass_transform__" || decoratorCallType.details.builtInName === "dataclass_transform") {
+            undecoratedType.details.decoratorDataClassBehaviors = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluator, decoratorNode.expression);
+            return inputFunctionType;
+          }
+          if (decoratorCallType.details.builtInName === "deprecated") {
+            undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+            return inputFunctionType;
+          }
+        }
+        if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
+          if (decoratorCallType.overloads.length > 0 && decoratorCallType.overloads[0].details.builtInName === "deprecated") {
+            undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+            return inputFunctionType;
+          }
+        }
+      }
+      let returnType = getTypeOfDecorator(evaluator, decoratorNode, inputFunctionType);
+      if ((0, types_1.isFunction)(decoratorType)) {
+        if (decoratorType.details.builtInName === "abstractmethod") {
+          return inputFunctionType;
+        }
+        if (decoratorType.details.builtInName === "deprecated") {
+          undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+          return inputFunctionType;
+        }
+        if (decoratorNode.expression.nodeType === 35) {
+          const baseType = evaluator.getTypeOfExpression(
+            decoratorNode.expression.leftExpression,
+            evaluatorFlags | 2
+            /* DoNotSpecialize */
+          ).type;
+          if ((0, typeUtils_1.isProperty)(baseType)) {
+            const memberName = decoratorNode.expression.memberName.value;
+            if (memberName === "setter") {
+              if ((0, types_1.isFunction)(inputFunctionType)) {
+                (0, properties_1.validatePropertyMethod)(evaluator, inputFunctionType, decoratorNode);
+                return (0, properties_1.clonePropertyWithSetter)(evaluator, baseType, inputFunctionType, functionNode);
+              } else {
+                return inputFunctionType;
+              }
+            } else if (memberName === "deleter") {
+              if ((0, types_1.isFunction)(inputFunctionType)) {
+                (0, properties_1.validatePropertyMethod)(evaluator, inputFunctionType, decoratorNode);
+                return (0, properties_1.clonePropertyWithDeleter)(evaluator, baseType, inputFunctionType, functionNode);
+              } else {
+                return inputFunctionType;
+              }
+            }
+          }
+        }
+      } else if ((0, types_1.isOverloadedFunction)(decoratorType)) {
+        if (decoratorType.overloads.length > 0 && decoratorType.overloads[0].details.builtInName === "deprecated") {
+          undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+          return inputFunctionType;
+        }
+      } else if ((0, types_1.isInstantiableClass)(decoratorType)) {
+        if (types_1.ClassType.isBuiltIn(decoratorType)) {
+          switch (decoratorType.details.name) {
+            case "classmethod":
+            case "staticmethod": {
+              const requiredFlag = decoratorType.details.name === "classmethod" ? 2 : 4;
+              if ((0, types_1.isFunction)(inputFunctionType) && (inputFunctionType.details.flags & requiredFlag) === 0) {
+                const newFunction = types_1.FunctionType.clone(inputFunctionType);
+                newFunction.details.flags &= ~(1 | 4 | 2);
+                newFunction.details.flags |= requiredFlag;
+                return newFunction;
+              }
+              return inputFunctionType;
+            }
+          }
+        }
+        if (types_1.ClassType.isPropertyClass(decoratorType)) {
+          if ((0, types_1.isFunction)(inputFunctionType)) {
+            (0, properties_1.validatePropertyMethod)(evaluator, inputFunctionType, decoratorNode);
+            return (0, properties_1.createProperty)(evaluator, decoratorNode, decoratorType, inputFunctionType);
+          } else if ((0, types_1.isClassInstance)(inputFunctionType)) {
+            const boundMethod = evaluator.getBoundMethod(inputFunctionType, "__call__");
+            if (boundMethod && (0, types_1.isFunction)(boundMethod)) {
+              return (0, properties_1.createProperty)(evaluator, decoratorNode, decoratorType, boundMethod);
+            }
+            return types_1.UnknownType.create();
+          }
+        }
+      }
+      if ((0, types_1.isFunction)(inputFunctionType) && (0, types_1.isFunction)(returnType)) {
+        returnType = types_1.FunctionType.clone(returnType);
+        if (types_1.FunctionType.isOverloaded(inputFunctionType)) {
+          returnType.details.flags |= 256;
+        }
+        if (!returnType.details.docString) {
+          returnType.details.docString = inputFunctionType.details.docString;
+        }
+      }
+      return returnType;
+    }
+    exports.applyFunctionDecorator = applyFunctionDecorator;
+    function applyClassDecorator(evaluator, inputClassType, originalClassType, decoratorNode) {
+      const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(decoratorNode);
+      let flags = fileInfo.isStubFile ? 4 : 0;
+      if (decoratorNode.expression.nodeType !== 9) {
+        flags |= 2;
+      }
+      const decoratorType = evaluator.getTypeOfExpression(decoratorNode.expression, flags).type;
+      if (decoratorNode.expression.nodeType === 9) {
+        const decoratorCallType = evaluator.getTypeOfExpression(
+          decoratorNode.expression.leftExpression,
+          flags | 2
+          /* DoNotSpecialize */
+        ).type;
+        if ((0, types_1.isFunction)(decoratorCallType)) {
+          if (decoratorCallType.details.name === "__dataclass_transform__" || decoratorCallType.details.builtInName === "dataclass_transform") {
+            originalClassType.details.classDataClassTransform = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluator, decoratorNode.expression);
+          } else if (decoratorCallType.details.builtInName === "deprecated") {
+            originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+            return inputClassType;
+          }
+        }
+        if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
+          if (decoratorCallType.overloads.length > 0 && decoratorCallType.overloads[0].details.builtInName === "deprecated") {
+            originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+            return inputClassType;
+          }
+        }
+      }
+      if ((0, types_1.isOverloadedFunction)(decoratorType)) {
+        const dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType);
+        if (dataclassBehaviors) {
+          (0, dataClasses_1.applyDataClassDecorator)(
+            evaluator,
+            decoratorNode,
+            originalClassType,
+            dataclassBehaviors,
+            /* callNode */
+            void 0
+          );
+          return inputClassType;
+        }
+        if (decoratorType.overloads.length > 0 && decoratorType.overloads[0].details.builtInName === "deprecated") {
+          originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+          return inputClassType;
+        }
+      } else if ((0, types_1.isFunction)(decoratorType)) {
+        if (decoratorType.details.builtInName === "final") {
+          originalClassType.details.flags |= 4096;
+          return inputClassType;
+        }
+        if (decoratorType.details.builtInName === "deprecated") {
+          originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+          return inputClassType;
+        }
+        if (decoratorType.details.builtInName === "runtime_checkable") {
+          originalClassType.details.flags |= 32768;
+          return inputClassType;
+        }
+        let dataclassBehaviors;
+        let callNode;
+        if (decoratorNode.expression.nodeType === 9) {
+          callNode = decoratorNode.expression;
+          const decoratorCallType = evaluator.getTypeOfExpression(
+            callNode.leftExpression,
+            flags | 2
+            /* DoNotSpecialize */
+          ).type;
+          dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorCallType);
+        } else {
+          const decoratorType2 = evaluator.getTypeOfExpression(decoratorNode.expression, flags).type;
+          dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType2);
+        }
+        if (dataclassBehaviors) {
+          (0, dataClasses_1.applyDataClassDecorator)(evaluator, decoratorNode, originalClassType, dataclassBehaviors, callNode);
+          return inputClassType;
+        }
+      }
+      return getTypeOfDecorator(evaluator, decoratorNode, inputClassType);
+    }
+    exports.applyClassDecorator = applyClassDecorator;
+    function getTypeOfDecorator(evaluator, node, functionOrClassType) {
+      let flags = (0, analyzerNodeInfo_1.getFileInfo)(node).isStubFile ? 4 : 0;
+      if (node.expression.nodeType !== 9) {
+        flags |= 2;
+      }
+      const decoratorTypeResult = evaluator.getTypeOfExpression(node.expression, flags);
+      if ((0, types_1.isFunction)(decoratorTypeResult.type) && decoratorTypeResult.type.details.builtInName === "type_check_only") {
+        return functionOrClassType;
+      }
+      if ((0, types_1.isInstantiableClass)(decoratorTypeResult.type) && types_1.ClassType.isBuiltIn(decoratorTypeResult.type, "classmethod") && (0, typeUtils_1.isProperty)(functionOrClassType)) {
+        return functionOrClassType;
+      }
+      const argList = [
+        {
+          argumentCategory: 0,
+          typeResult: { type: functionOrClassType }
+        }
+      ];
+      const returnType = evaluator.validateCallArguments(
+        node.expression,
+        argList,
+        decoratorTypeResult,
+        /* typeVarContext */
+        void 0,
+        /* skipUnknownArgCheck */
+        true
+      ).returnType || types_1.UnknownType.create();
+      if ((0, types_1.isFunction)(returnType) && !returnType.details.declaredReturnType) {
+        if (!returnType.details.parameters.some((param, index) => {
+          if (!param.name || param.hasDeclaredType) {
+            return true;
+          }
+          if (param.category !== 0) {
+            return false;
+          }
+          return index !== 0 || !param.isTypeInferred;
+        })) {
+          return functionOrClassType;
+        }
+      }
+      if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
+        if ((0, types_1.isFunction)(decoratorTypeResult.type)) {
+          if (!decoratorTypeResult.type.details.parameters.find((param) => param.typeAnnotation !== void 0) && decoratorTypeResult.type.details.declaredReturnType === void 0) {
+            return functionOrClassType;
+          }
+        }
+      }
+      return returnType;
+    }
+    function addOverloadsToFunctionType(evaluator, node, type) {
+      let functionDecl;
+      const decl = (0, analyzerNodeInfo_1.getDeclaration)(node);
+      if (decl) {
+        functionDecl = decl;
+      }
+      const symbolWithScope = evaluator.lookUpSymbolRecursive(
+        node,
+        node.name.value,
+        /* honorCodeFlow */
+        false
+      );
+      if (symbolWithScope) {
+        const decls = symbolWithScope.symbol.getDeclarations();
+        const declIndex = decls.findIndex((decl2) => decl2 === functionDecl);
+        if (declIndex > 0) {
+          for (let i = 0; i < declIndex; i++) {
+            const decl2 = decls[i];
+            if (decl2.type === 5) {
+              evaluator.getTypeOfFunction(decl2.node);
+            }
+          }
+          let overloadedTypes = [];
+          const prevDecl = decls[declIndex - 1];
+          if (prevDecl.type === 5) {
+            const prevDeclDeclTypeInfo = evaluator.getTypeOfFunction(prevDecl.node);
+            if (prevDeclDeclTypeInfo) {
+              if ((0, types_1.isFunction)(prevDeclDeclTypeInfo.decoratedType)) {
+                if (types_1.FunctionType.isOverloaded(prevDeclDeclTypeInfo.decoratedType)) {
+                  overloadedTypes.push(prevDeclDeclTypeInfo.decoratedType);
+                }
+              } else if ((0, types_1.isOverloadedFunction)(prevDeclDeclTypeInfo.decoratedType)) {
+                (0, collectionUtils_1.appendArray)(overloadedTypes, prevDeclDeclTypeInfo.decoratedType.overloads);
+              }
+            }
+          }
+          overloadedTypes.push(type);
+          if (overloadedTypes.length === 1) {
+            return overloadedTypes[0];
+          }
+          const implementation = overloadedTypes.find((signature) => !types_1.FunctionType.isOverloaded(signature));
+          if (implementation === null || implementation === void 0 ? void 0 : implementation.details.docString) {
+            overloadedTypes = overloadedTypes.map((overload) => {
+              if (types_1.FunctionType.isOverloaded(overload) && !overload.details.docString) {
+                return types_1.FunctionType.cloneWithDocString(overload, implementation.details.docString);
+              }
+              return overload;
+            });
+          }
+          const newOverload = types_1.OverloadedFunctionType.create(overloadedTypes);
+          const prevOverload = overloadedTypes[overloadedTypes.length - 2];
+          const isPrevOverloadAbstract = types_1.FunctionType.isAbstractMethod(prevOverload);
+          const isCurrentOverloadAbstract = types_1.FunctionType.isAbstractMethod(type);
+          if (isPrevOverloadAbstract !== isCurrentOverloadAbstract) {
+            evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadAbstractMismatch().format({ name: node.name.value }), node.name);
+          }
+          return newOverload;
+        }
+      }
+      return type;
+    }
+    exports.addOverloadsToFunctionType = addOverloadsToFunctionType;
+    function getCustomDeprecationMessage(decorator) {
+      if (decorator.expression.nodeType === 9 && decorator.expression.arguments.length > 0 && decorator.expression.arguments[0].argumentCategory === 0 && decorator.expression.arguments[0].valueExpression.nodeType === 48 && decorator.expression.arguments[0].valueExpression.strings.length === 1) {
+        return decorator.expression.arguments[0].valueExpression.strings[0].value;
+      }
+      return "";
+    }
+  }
+});
+
 // node_modules/@zzzen/pyright-internal/dist/analyzer/enums.js
 var require_enums = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/analyzer/enums.js"(exports) {
@@ -49074,14 +50019,14 @@ var require_operations = __commonJS({
       return type && (0, types_1.isNever)(type) ? void 0 : type;
     }
     exports.validateBinaryOperation = validateBinaryOperation;
-    function getTypeOfBinaryOperation(evaluator, node, inferenceContext, flags) {
+    function getTypeOfBinaryOperation(evaluator, node, flags, inferenceContext) {
       const leftExpression = node.leftExpression;
       let rightExpression = node.rightExpression;
       let isIncomplete = false;
       let typeErrors = false;
       if ((0, parseTreeUtils_1.operatorSupportsChaining)(node.operator)) {
         if (rightExpression.nodeType === 7 && !rightExpression.parenthesized && (0, parseTreeUtils_1.operatorSupportsChaining)(rightExpression.operator)) {
-          getTypeOfBinaryOperation(evaluator, rightExpression, inferenceContext, flags);
+          getTypeOfBinaryOperation(evaluator, rightExpression, flags, inferenceContext);
           rightExpression = rightExpression.leftExpression;
         }
       }
@@ -49132,13 +50077,13 @@ var require_operations = __commonJS({
             node.leftExpression,
             adjustedLeftType,
             flags | 128
-            /* ExpectingType */
+            /* ExpectingInstantiableType */
           );
           adjustedRightType = evaluator.reportMissingTypeArguments(
             node.rightExpression,
             adjustedRightType,
             flags | 128
-            /* ExpectingType */
+            /* ExpectingInstantiableType */
           );
           const newUnion = (0, types_1.combineTypes)([adjustedLeftType, adjustedRightType]);
           if ((0, types_1.isUnion)(newUnion)) {
@@ -49529,407 +50474,6 @@ var require_operations = __commonJS({
   }
 });
 
-// node_modules/@zzzen/pyright-internal/dist/analyzer/properties.js
-var require_properties = __commonJS({
-  "node_modules/@zzzen/pyright-internal/dist/analyzer/properties.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.assignProperty = exports.clonePropertyWithDeleter = exports.clonePropertyWithSetter = exports.createProperty = exports.validatePropertyMethod = void 0;
-    var diagnostic_1 = require_diagnostic();
-    var diagnosticRules_1 = require_diagnosticRules();
-    var localize_1 = require_localize();
-    var analyzerNodeInfo_1 = require_analyzerNodeInfo();
-    var parseTreeUtils_1 = require_parseTreeUtils();
-    var symbol_1 = require_symbol();
-    var types_1 = require_types();
-    var typeUtils_1 = require_typeUtils();
-    function validatePropertyMethod(evaluator, method2, errorNode) {
-      if (types_1.FunctionType.isStaticMethod(method2)) {
-        evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.propertyStaticMethod(), errorNode);
-      }
-    }
-    exports.validatePropertyMethod = validatePropertyMethod;
-    function createProperty(evaluator, decoratorNode, decoratorType, fget) {
-      const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(decoratorNode);
-      const typeMetaclass = evaluator.getBuiltInType(decoratorNode, "type");
-      const typeSourceId = types_1.ClassType.isBuiltIn(decoratorType, "property") ? (0, parseTreeUtils_1.getTypeSourceId)(decoratorNode) : decoratorType.details.typeSourceId;
-      const propertyClass = types_1.ClassType.createInstantiable(
-        decoratorType.details.name,
-        (0, parseTreeUtils_1.getClassFullName)(decoratorNode, fileInfo.moduleName, `__property_${fget.details.name}`),
-        fileInfo.moduleName,
-        fileInfo.filePath,
-        2048 | 1,
-        typeSourceId,
-        /* declaredMetaclass */
-        void 0,
-        (0, types_1.isInstantiableClass)(typeMetaclass) ? typeMetaclass : types_1.UnknownType.create()
-      );
-      propertyClass.details.typeVarScopeId = decoratorType.details.typeVarScopeId;
-      const objectType = evaluator.getBuiltInType(decoratorNode, "object");
-      propertyClass.details.baseClasses.push((0, types_1.isInstantiableClass)(objectType) ? objectType : types_1.UnknownType.create());
-      (0, typeUtils_1.computeMroLinearization)(propertyClass);
-      const fields = propertyClass.details.fields;
-      decoratorType.details.fields.forEach((symbol, name) => {
-        const ignoredMethods = ["__get__", "__set__", "__delete__", "fget", "fset", "fdel"];
-        if (!symbol.isIgnoredForProtocolMatch()) {
-          if (!ignoredMethods.some((m) => m === name)) {
-            fields.set(name, symbol);
-          }
-        }
-      });
-      const propertyObject = types_1.ClassType.cloneAsInstance(propertyClass);
-      propertyClass.isAsymmetricDescriptor = false;
-      updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
-      const fgetSymbol = symbol_1.Symbol.createWithType(4, types_1.FunctionType.cloneWithNewFlags(
-        fget,
-        fget.details.flags | 4
-        /* StaticMethod */
-      ));
-      fields.set("fget", fgetSymbol);
-      if (types_1.FunctionType.isClassMethod(fget)) {
-        propertyClass.details.flags |= 4194304;
-      }
-      addGetMethodToPropertySymbolTable(evaluator, propertyObject, fget);
-      addDecoratorMethodsToPropertySymbolTable(propertyObject);
-      return propertyObject;
-    }
-    exports.createProperty = createProperty;
-    function clonePropertyWithSetter(evaluator, prop, fset, errorNode) {
-      if (!(0, typeUtils_1.isProperty)(prop)) {
-        return prop;
-      }
-      const classType = prop;
-      const flagsToClone = classType.details.flags;
-      let isAsymmetricDescriptor = !!classType.isAsymmetricDescriptor;
-      const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
-      if (errorNode.parameters.length >= 2) {
-        const typeAnnotation = (0, parseTreeUtils_1.getTypeAnnotationForParameter)(errorNode, 1);
-        if (typeAnnotation) {
-          const fgetType = evaluator.getGetterTypeFromProperty(
-            classType,
-            /* inferTypeIfNeeded */
-            false
-          );
-          if (fgetType && !(0, types_1.isAnyOrUnknown)(fgetType)) {
-            const fsetType = evaluator.getTypeOfAnnotation(typeAnnotation, {
-              associateTypeVarsWithScope: true
-            });
-            if (fileInfo.diagnosticRuleSet.reportPropertyTypeMismatch !== "none") {
-              const diag = new diagnostic_1.DiagnosticAddendum();
-              if (!evaluator.assignType(fgetType, fsetType, diag)) {
-                evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportPropertyTypeMismatch, diagnosticRules_1.DiagnosticRule.reportPropertyTypeMismatch, localize_1.Localizer.Diagnostic.setterGetterTypeMismatch() + diag.getString(), typeAnnotation);
-              }
-            }
-            if (!(0, types_1.isTypeSame)(fgetType, fsetType)) {
-              isAsymmetricDescriptor = true;
-            }
-          }
-        }
-      }
-      const propertyClass = types_1.ClassType.createInstantiable(classType.details.name, classType.details.fullName, classType.details.moduleName, (0, analyzerNodeInfo_1.getFileInfo)(errorNode).filePath, flagsToClone, classType.details.typeSourceId, classType.details.declaredMetaclass, classType.details.effectiveMetaclass);
-      propertyClass.details.typeVarScopeId = classType.details.typeVarScopeId;
-      const objectType = evaluator.getBuiltInType(errorNode, "object");
-      propertyClass.details.baseClasses.push((0, types_1.isInstantiableClass)(objectType) ? objectType : types_1.UnknownType.create());
-      (0, typeUtils_1.computeMroLinearization)(propertyClass);
-      propertyClass.isAsymmetricDescriptor = isAsymmetricDescriptor;
-      const propertyObject = types_1.ClassType.cloneAsInstance(propertyClass);
-      const fields = propertyClass.details.fields;
-      classType.details.fields.forEach((symbol, name) => {
-        if (!symbol.isIgnoredForProtocolMatch()) {
-          fields.set(name, symbol);
-        }
-      });
-      updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
-      const fsetSymbol = symbol_1.Symbol.createWithType(4, types_1.FunctionType.cloneWithNewFlags(
-        fset,
-        fset.details.flags | 4
-        /* StaticMethod */
-      ));
-      fields.set("fset", fsetSymbol);
-      addSetMethodToPropertySymbolTable(evaluator, propertyObject, fset);
-      addDecoratorMethodsToPropertySymbolTable(propertyObject);
-      return propertyObject;
-    }
-    exports.clonePropertyWithSetter = clonePropertyWithSetter;
-    function clonePropertyWithDeleter(evaluator, prop, fdel, errorNode) {
-      var _a;
-      if (!(0, typeUtils_1.isProperty)(prop)) {
-        return prop;
-      }
-      const classType = prop;
-      const propertyClass = types_1.ClassType.createInstantiable(classType.details.name, classType.details.fullName, classType.details.moduleName, (0, analyzerNodeInfo_1.getFileInfo)(errorNode).filePath, classType.details.flags, classType.details.typeSourceId, classType.details.declaredMetaclass, classType.details.effectiveMetaclass);
-      propertyClass.details.typeVarScopeId = classType.details.typeVarScopeId;
-      const objectType = evaluator.getBuiltInType(errorNode, "object");
-      propertyClass.details.baseClasses.push((0, types_1.isInstantiableClass)(objectType) ? objectType : types_1.UnknownType.create());
-      (0, typeUtils_1.computeMroLinearization)(propertyClass);
-      const propertyObject = types_1.ClassType.cloneAsInstance(propertyClass);
-      propertyClass.isAsymmetricDescriptor = (_a = classType.isAsymmetricDescriptor) !== null && _a !== void 0 ? _a : false;
-      const fields = propertyClass.details.fields;
-      classType.details.fields.forEach((symbol, name) => {
-        if (!symbol.isIgnoredForProtocolMatch()) {
-          fields.set(name, symbol);
-        }
-      });
-      updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
-      const fdelSymbol = symbol_1.Symbol.createWithType(4, types_1.FunctionType.cloneWithNewFlags(
-        fdel,
-        fdel.details.flags | 4
-        /* StaticMethod */
-      ));
-      fields.set("fdel", fdelSymbol);
-      addDelMethodToPropertySymbolTable(evaluator, propertyObject, fdel);
-      addDecoratorMethodsToPropertySymbolTable(propertyObject);
-      return propertyObject;
-    }
-    exports.clonePropertyWithDeleter = clonePropertyWithDeleter;
-    function addGetMethodToPropertySymbolTable(evaluator, propertyObject, fget) {
-      const fields = propertyObject.details.fields;
-      const getFunction1 = types_1.FunctionType.createSynthesizedInstance(
-        "__get__",
-        256
-        /* Overloaded */
-      );
-      types_1.FunctionType.addParameter(getFunction1, {
-        category: 0,
-        name: "self",
-        type: types_1.AnyType.create(),
-        hasDeclaredType: true
-      });
-      types_1.FunctionType.addParameter(getFunction1, {
-        category: 0,
-        name: "obj",
-        type: types_1.NoneType.createInstance(),
-        hasDeclaredType: true
-      });
-      types_1.FunctionType.addParameter(getFunction1, {
-        category: 0,
-        name: "objtype",
-        type: types_1.AnyType.create(),
-        hasDeclaredType: true,
-        hasDefault: true,
-        defaultType: types_1.AnyType.create()
-      });
-      getFunction1.details.declaredReturnType = types_1.FunctionType.isClassMethod(fget) ? types_1.FunctionType.getSpecializedReturnType(fget) : propertyObject;
-      getFunction1.details.declaration = fget.details.declaration;
-      getFunction1.details.typeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(fget);
-      const getFunction2 = types_1.FunctionType.createSynthesizedInstance(
-        "__get__",
-        256
-        /* Overloaded */
-      );
-      types_1.FunctionType.addParameter(getFunction2, {
-        category: 0,
-        name: "self",
-        type: types_1.AnyType.create(),
-        hasDeclaredType: true
-      });
-      const objType = fget.details.parameters.length > 0 ? fget.details.parameters[0].type : types_1.AnyType.create();
-      types_1.FunctionType.addParameter(getFunction2, {
-        category: 0,
-        name: "obj",
-        type: objType,
-        hasDeclaredType: true
-      });
-      types_1.FunctionType.addParameter(getFunction2, {
-        category: 0,
-        name: "objtype",
-        type: types_1.AnyType.create(),
-        hasDeclaredType: true,
-        hasDefault: true,
-        defaultType: types_1.AnyType.create()
-      });
-      getFunction2.details.declaredReturnType = types_1.FunctionType.getSpecializedReturnType(fget);
-      getFunction2.details.declaration = fget.details.declaration;
-      getFunction2.details.typeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(fget);
-      const getFunctionOverload = types_1.OverloadedFunctionType.create([getFunction2, getFunction1]);
-      const getSymbol = symbol_1.Symbol.createWithType(4, getFunctionOverload);
-      fields.set("__get__", getSymbol);
-    }
-    function addSetMethodToPropertySymbolTable(evaluator, propertyObject, fset) {
-      const fields = propertyObject.details.fields;
-      const setFunction = types_1.FunctionType.createSynthesizedInstance("__set__");
-      types_1.FunctionType.addParameter(setFunction, {
-        category: 0,
-        name: "self",
-        type: types_1.AnyType.create(),
-        hasDeclaredType: true
-      });
-      let objType = fset.details.parameters.length > 0 ? fset.details.parameters[0].type : types_1.AnyType.create();
-      if ((0, types_1.isTypeVar)(objType) && objType.details.isSynthesizedSelf) {
-        objType = evaluator.makeTopLevelTypeVarsConcrete(objType);
-      }
-      types_1.FunctionType.addParameter(setFunction, {
-        category: 0,
-        name: "obj",
-        type: (0, types_1.combineTypes)([objType, types_1.NoneType.createInstance()]),
-        hasDeclaredType: true
-      });
-      setFunction.details.declaredReturnType = types_1.NoneType.createInstance();
-      setFunction.details.typeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(fset);
-      let setParamType = types_1.UnknownType.create();
-      if (fset.details.parameters.length >= 2 && fset.details.parameters[1].category === 0 && fset.details.parameters[1].name) {
-        setParamType = fset.details.parameters[1].type;
-      }
-      types_1.FunctionType.addParameter(setFunction, {
-        category: 0,
-        name: "value",
-        type: setParamType,
-        hasDeclaredType: true
-      });
-      const setSymbol = symbol_1.Symbol.createWithType(4, setFunction);
-      fields.set("__set__", setSymbol);
-    }
-    function addDelMethodToPropertySymbolTable(evaluator, propertyObject, fdel) {
-      const fields = propertyObject.details.fields;
-      const delFunction = types_1.FunctionType.createSynthesizedInstance("__delete__");
-      types_1.FunctionType.addParameter(delFunction, {
-        category: 0,
-        name: "self",
-        type: types_1.AnyType.create(),
-        hasDeclaredType: true
-      });
-      delFunction.details.typeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(fdel);
-      let objType = fdel.details.parameters.length > 0 ? fdel.details.parameters[0].type : types_1.AnyType.create();
-      if ((0, types_1.isTypeVar)(objType) && objType.details.isSynthesizedSelf) {
-        objType = evaluator.makeTopLevelTypeVarsConcrete(objType);
-      }
-      types_1.FunctionType.addParameter(delFunction, {
-        category: 0,
-        name: "obj",
-        type: (0, types_1.combineTypes)([objType, types_1.NoneType.createInstance()]),
-        hasDeclaredType: true
-      });
-      delFunction.details.declaredReturnType = types_1.NoneType.createInstance();
-      const delSymbol = symbol_1.Symbol.createWithType(4, delFunction);
-      fields.set("__delete__", delSymbol);
-    }
-    function updateGetSetDelMethodForClonedProperty(evaluator, propertyObject) {
-      const fields = propertyObject.details.fields;
-      const fgetSymbol = fields.get("fget");
-      const fgetType = fgetSymbol === null || fgetSymbol === void 0 ? void 0 : fgetSymbol.getSynthesizedType();
-      if (fgetType && (0, types_1.isFunction)(fgetType)) {
-        addGetMethodToPropertySymbolTable(evaluator, propertyObject, fgetType);
-      }
-      const fsetSymbol = fields.get("fset");
-      const fsetType = fsetSymbol === null || fsetSymbol === void 0 ? void 0 : fsetSymbol.getSynthesizedType();
-      if (fsetType && (0, types_1.isFunction)(fsetType)) {
-        addSetMethodToPropertySymbolTable(evaluator, propertyObject, fsetType);
-      }
-      const fdelSymbol = fields.get("fdel");
-      const fdelType = fdelSymbol === null || fdelSymbol === void 0 ? void 0 : fdelSymbol.getSynthesizedType();
-      if (fdelType && (0, types_1.isFunction)(fdelType)) {
-        addDelMethodToPropertySymbolTable(evaluator, propertyObject, fdelType);
-      }
-    }
-    function addDecoratorMethodsToPropertySymbolTable(propertyObject) {
-      const fields = propertyObject.details.fields;
-      ["getter", "setter", "deleter"].forEach((accessorName) => {
-        const accessorFunction = types_1.FunctionType.createSynthesizedInstance(accessorName);
-        types_1.FunctionType.addParameter(accessorFunction, {
-          category: 0,
-          name: "self",
-          type: types_1.AnyType.create(),
-          hasDeclaredType: true
-        });
-        types_1.FunctionType.addParameter(accessorFunction, {
-          category: 0,
-          name: "accessor",
-          type: types_1.AnyType.create(),
-          hasDeclaredType: true
-        });
-        accessorFunction.details.declaredReturnType = propertyObject;
-        const accessorSymbol = symbol_1.Symbol.createWithType(4, accessorFunction);
-        fields.set(accessorName, accessorSymbol);
-      });
-    }
-    function assignProperty(evaluator, destPropertyType, srcPropertyType, destClass, srcClass, diag, typeVarContext, selfTypeVarContext, recursionCount = 0) {
-      const srcObjectToBind = types_1.ClassType.cloneAsInstance(srcClass);
-      const destObjectToBind = types_1.ClassType.cloneAsInstance(destClass);
-      let isAssignable = true;
-      const accessors = [
-        {
-          name: "fget",
-          missingDiagMsg: localize_1.Localizer.DiagnosticAddendum.missingGetter,
-          incompatibleDiagMsg: localize_1.Localizer.DiagnosticAddendum.incompatibleGetter
-        },
-        {
-          name: "fset",
-          missingDiagMsg: localize_1.Localizer.DiagnosticAddendum.missingSetter,
-          incompatibleDiagMsg: localize_1.Localizer.DiagnosticAddendum.incompatibleSetter
-        },
-        {
-          name: "fdel",
-          missingDiagMsg: localize_1.Localizer.DiagnosticAddendum.missingDeleter,
-          incompatibleDiagMsg: localize_1.Localizer.DiagnosticAddendum.incompatibleDeleter
-        }
-      ];
-      accessors.forEach((accessorInfo) => {
-        var _a, _b;
-        const destAccessSymbol = destPropertyType.details.fields.get(accessorInfo.name);
-        let destAccessType = destAccessSymbol ? (_a = evaluator.getDeclaredTypeOfSymbol(destAccessSymbol)) === null || _a === void 0 ? void 0 : _a.type : void 0;
-        if (destAccessType && (0, types_1.isFunction)(destAccessType)) {
-          const srcAccessSymbol = srcPropertyType.details.fields.get(accessorInfo.name);
-          let srcAccessType = srcAccessSymbol ? (_b = evaluator.getDeclaredTypeOfSymbol(srcAccessSymbol)) === null || _b === void 0 ? void 0 : _b.type : void 0;
-          if (!srcAccessType || !(0, types_1.isFunction)(srcAccessType)) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(accessorInfo.missingDiagMsg());
-            isAssignable = false;
-            return;
-          }
-          evaluator.inferReturnTypeIfNecessary(srcAccessType);
-          srcAccessType = (0, typeUtils_1.partiallySpecializeType)(srcAccessType, srcClass);
-          evaluator.inferReturnTypeIfNecessary(destAccessType);
-          destAccessType = (0, typeUtils_1.partiallySpecializeType)(destAccessType, destClass);
-          if (selfTypeVarContext) {
-            destAccessType = (0, typeUtils_1.applySolvedTypeVars)(destAccessType, selfTypeVarContext);
-          }
-          destAccessType = types_1.FunctionType.cloneWithNewFlags(
-            destAccessType,
-            destAccessType.details.flags & ~4
-            /* StaticMethod */
-          );
-          srcAccessType = types_1.FunctionType.cloneWithNewFlags(
-            srcAccessType,
-            srcAccessType.details.flags & ~4
-            /* StaticMethod */
-          );
-          const boundDestAccessType = evaluator.bindFunctionToClassOrObject(
-            destObjectToBind,
-            destAccessType,
-            /* memberClass */
-            void 0,
-            /* errorNode */
-            void 0,
-            recursionCount
-          );
-          const boundSrcAccessType = evaluator.bindFunctionToClassOrObject(
-            srcObjectToBind,
-            srcAccessType,
-            /* memberClass */
-            void 0,
-            /* errorNode */
-            void 0,
-            recursionCount
-          );
-          if (!boundDestAccessType || !boundSrcAccessType || !evaluator.assignType(
-            boundDestAccessType,
-            boundSrcAccessType,
-            diag,
-            typeVarContext,
-            /* srcTypeVarContext */
-            void 0,
-            0,
-            recursionCount
-          )) {
-            isAssignable = false;
-          }
-        }
-      });
-      return isAssignable;
-    }
-    exports.assignProperty = assignProperty;
-  }
-});
-
 // node_modules/@zzzen/pyright-internal/dist/analyzer/protocols.js
 var require_protocols = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/analyzer/protocols.js"(exports) {
@@ -50200,7 +50744,7 @@ var require_protocols = __commonJS({
         );
         const specializedProtocolType = (0, typeUtils_1.applySolvedTypeVars)(genericProtocolType, protocolTypeVarContext);
         if (destType.typeArguments) {
-          if (!evaluator.verifyTypeArgumentsAssignable(destType, specializedProtocolType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+          if (!evaluator.assignTypeArguments(destType, specializedProtocolType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
             typesAreConsistent = false;
           }
         } else if (destTypeVarContext && !destTypeVarContext.isLocked()) {
@@ -50285,7 +50829,7 @@ var require_protocols = __commonJS({
           false
         );
         const specializedProtocolType = (0, typeUtils_1.applySolvedTypeVars)(genericProtocolType, protocolTypeVarContext);
-        if (!evaluator.verifyTypeArgumentsAssignable(
+        if (!evaluator.assignTypeArguments(
           destType,
           specializedProtocolType,
           diag,
@@ -50562,6 +51106,7 @@ var require_typePrinter = __commonJS({
       PrintTypeFlags2[PrintTypeFlags2["PythonSyntax"] = 256] = "PythonSyntax";
       PrintTypeFlags2[PrintTypeFlags2["UseTypingUnpack"] = 512] = "UseTypingUnpack";
       PrintTypeFlags2[PrintTypeFlags2["ExpandTypedDictArgs"] = 1024] = "ExpandTypedDictArgs";
+      PrintTypeFlags2[PrintTypeFlags2["PrintTypeVarVariance"] = 2048] = "PrintTypeVarVariance";
     })(PrintTypeFlags = exports.PrintTypeFlags || (exports.PrintTypeFlags = {}));
     function printType(type, printTypeFlags, returnTypeCallback) {
       const uniqueNameMap = new UniqueNameMap(printTypeFlags, returnTypeCallback);
@@ -50765,8 +51310,8 @@ var require_typePrinter = __commonJS({
           }
           case 5: {
             if (types_1.TypeBase.isInstantiable(type)) {
-              const typeString = printFunctionType(types_1.TypeBase.cloneTypeAsInstance(type), printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
-              return `Type[${typeString}]`;
+              const typeString = printFunctionType(types_1.FunctionType.cloneAsInstance(type), printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
+              return `type[${typeString}]`;
             }
             return printFunctionType(type, originalPrintTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
           }
@@ -50851,7 +51396,7 @@ var require_typePrinter = __commonJS({
             if (literalClassStrings.size > 0) {
               const literalStrings = [];
               literalClassStrings.forEach((s) => literalStrings.push(s));
-              dedupedSubtypeStrings.push(`Type[Literal[${literalStrings.join(", ")}]]`);
+              dedupedSubtypeStrings.push(`type[Literal[${literalStrings.join(", ")}]]`);
             }
             if (dedupedSubtypeStrings.length === 1) {
               return dedupedSubtypeStrings[0];
@@ -50903,7 +51448,13 @@ var require_typePrinter = __commonJS({
               typeVarName = `Union[${typeVarName}]`;
             }
             if (types_1.TypeBase.isInstantiable(type)) {
-              return `${_printNestedInstantiable(type, typeVarName)}`;
+              typeVarName = `${_printNestedInstantiable(type, typeVarName)}`;
+            }
+            if (!type.details.isVariadic && (printTypeFlags & 2048) !== 0) {
+              const varianceText = _getTypeVarVarianceText(type);
+              if (varianceText) {
+                typeVarName = `${typeVarName} (${varianceText})`;
+              }
             }
             return typeVarName;
           }
@@ -51186,7 +51737,7 @@ var require_typePrinter = __commonJS({
       var _a;
       const nestedTypes = ((_a = type.instantiableNestingLevel) !== null && _a !== void 0 ? _a : 0) + 1;
       for (let nestLevel = 0; nestLevel < nestedTypes; nestLevel++) {
-        textToWrap = `Type[${textToWrap}]`;
+        textToWrap = `type[${textToWrap}]`;
       }
       return textToWrap;
     }
@@ -51196,6 +51747,20 @@ var require_typePrinter = __commonJS({
       }
       return types_1.TypeVarType.getReadableName(type);
     }
+    function _getTypeVarVarianceText(type) {
+      var _a;
+      const computedVariance = (_a = type.computedVariance) !== null && _a !== void 0 ? _a : type.details.declaredVariance;
+      if (computedVariance === 2) {
+        return "invariant";
+      }
+      if (computedVariance === 3) {
+        return "covariant";
+      }
+      if (computedVariance === 4) {
+        return "contravariant";
+      }
+      return "";
+    }
     var UniqueNameMap = class {
       constructor(_printTypeFlags, _returnTypeCallback) {
         this._printTypeFlags = _printTypeFlags;
@@ -51368,6 +51933,7 @@ var require_typeEvaluator = __commonJS({
     var constructors_1 = require_constructors();
     var dataClasses_1 = require_dataClasses();
     var declarationUtils_1 = require_declarationUtils();
+    var decorators_1 = require_decorators();
     var enums_1 = require_enums();
     var functionTransform_1 = require_functionTransform();
     var namedTuples_1 = require_namedTuples();
@@ -51606,10 +52172,29 @@ var require_typeEvaluator = __commonJS({
         return void 0;
       }
       function getType(node) {
-        var _a;
-        return (_a = evaluateTypeForSubnode(node, () => {
+        var _a, _b;
+        let type = (_a = evaluateTypeForSubnode(node, () => {
           evaluateTypesForExpressionInContext(node);
         })) === null || _a === void 0 ? void 0 : _a.type;
+        if (type && (0, types_1.isTypeVar)(type) && type.details.declaredVariance === 0) {
+          const typeVarType = type;
+          const typeParamListNode = ParseTreeUtils.getParentNodeOfType(
+            node,
+            76
+            /* TypeParameterList */
+          );
+          if (((_b = typeParamListNode === null || typeParamListNode === void 0 ? void 0 : typeParamListNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 10) {
+            const classTypeResult = getTypeOfClass(typeParamListNode.parent);
+            if (classTypeResult) {
+              inferTypeParameterVarianceForClass(classTypeResult.classType);
+              const typeParam = classTypeResult.classType.details.typeParameters.find((param) => (0, types_1.isTypeSame)(param, typeVarType, { ignoreTypeFlags: true }));
+              if (typeParam) {
+                type = types_1.TypeBase.isInstance(type) ? types_1.TypeVarType.cloneAsInstance(typeParam) : typeParam;
+              }
+            }
+          }
+        }
+        return type;
       }
       function getTypeResult(node) {
         return evaluateTypeForSubnode(node, () => {
@@ -51671,7 +52256,6 @@ var require_typeEvaluator = __commonJS({
         }
       }
       function getTypeOfExpression(node, flags = 0, inferenceContext) {
-        var _a;
         const cacheEntry = readTypeCacheEntry(node);
         if (cacheEntry && (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount)) {
           if (printExpressionTypes) {
@@ -51697,7 +52281,7 @@ var require_typeEvaluator = __commonJS({
         }
         initializedBasicTypes(node);
         let typeResult;
-        let reportExpectingTypeErrors = (flags & 128) !== 0;
+        let expectingInstantiable = (flags & 128) !== 0;
         switch (node.nodeType) {
           case 38: {
             typeResult = getTypeOfName(node, flags);
@@ -51712,11 +52296,11 @@ var require_typeEvaluator = __commonJS({
             break;
           }
           case 9: {
-            typeResult = getTypeOfCall(node, inferenceContext, flags);
+            typeResult = getTypeOfCall(node, flags, inferenceContext);
             break;
           }
           case 52: {
-            typeResult = getTypeOfTuple(node, inferenceContext, flags);
+            typeResult = getTypeOfTuple(node, flags, inferenceContext);
             break;
           }
           case 11: {
@@ -51726,7 +52310,7 @@ var require_typeEvaluator = __commonJS({
           case 48: {
             const isExpectingType = (flags & 8) !== 0 && !isAnnotationLiteralValue(node);
             if (isExpectingType) {
-              reportExpectingTypeErrors = false;
+              expectingInstantiable = false;
             }
             typeResult = getTypeOfStringList(node, flags, isExpectingType);
             break;
@@ -51744,7 +52328,11 @@ var require_typeEvaluator = __commonJS({
             break;
           }
           case 7: {
-            typeResult = (0, operations_1.getTypeOfBinaryOperation)(evaluatorInterface, node, inferenceContext, flags);
+            let effectiveFlags = flags;
+            if (expectingInstantiable && node.operator !== 6) {
+              effectiveFlags &= ~128;
+            }
+            typeResult = (0, operations_1.getTypeOfBinaryOperation)(evaluatorInterface, node, effectiveFlags, inferenceContext);
             break;
           }
           case 5: {
@@ -51846,21 +52434,8 @@ var require_typeEvaluator = __commonJS({
         if (!typeResult) {
           (0, debug_1.fail)(`Unhandled expression type '${ParseTreeUtils.printExpression(node)}'`);
         }
-        if (reportExpectingTypeErrors && !typeResult.isIncomplete) {
-          if (flags & 64) {
-            if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicInUnion) {
-              addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), node);
-              typeResult.type = types_1.UnknownType.create();
-            }
-          }
-          if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeResult.type)) {
-            const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isTupleClass(typeResult.type) && ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
-            if (!isEmptyVariadic) {
-              addExpectedClassDiagnostic(typeResult.type, node);
-              typeResult.type = types_1.UnknownType.create();
-              typeResult.typeErrors = true;
-            }
-          }
+        if (expectingInstantiable) {
+          validateTypeIsInstantiable(typeResult, flags, node);
         }
         writeTypeCache(
           node,
@@ -51900,6 +52475,26 @@ var require_typeEvaluator = __commonJS({
         }
         return typeResult;
       }
+      function validateTypeIsInstantiable(typeResult, flags, node) {
+        var _a;
+        if (typeResult.isIncomplete) {
+          return;
+        }
+        if (flags & 64) {
+          if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicInUnion) {
+            addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), node);
+            typeResult.type = types_1.UnknownType.create();
+          }
+        }
+        if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeResult.type)) {
+          const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isTupleClass(typeResult.type) && ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
+          if (!isEmptyVariadic) {
+            addExpectedClassDiagnostic(typeResult.type, node);
+            typeResult.type = types_1.UnknownType.create();
+            typeResult.typeErrors = true;
+          }
+        }
+      }
       function getTypeOfAwaitOperator(node, flags, inferenceContext) {
         const effectiveExpectedType = inferenceContext ? createAwaitableReturnType(
           node,
@@ -52185,55 +52780,6 @@ var require_typeEvaluator = __commonJS({
         }
         return (0, typeUtils_1.convertToInstance)(annotationType);
       }
-      function getTypeOfDecorator(node, functionOrClassType) {
-        let flags = AnalyzerNodeInfo.getFileInfo(node).isStubFile ? 4 : 0;
-        if (node.expression.nodeType !== 9) {
-          flags |= 2;
-        }
-        const decoratorTypeResult = getTypeOfExpression(node.expression, flags);
-        if ((0, types_1.isFunction)(decoratorTypeResult.type) && decoratorTypeResult.type.details.builtInName === "type_check_only") {
-          return functionOrClassType;
-        }
-        if ((0, types_1.isInstantiableClass)(decoratorTypeResult.type) && types_1.ClassType.isBuiltIn(decoratorTypeResult.type, "classmethod") && (0, typeUtils_1.isProperty)(functionOrClassType)) {
-          return functionOrClassType;
-        }
-        const argList = [
-          {
-            argumentCategory: 0,
-            typeResult: { type: functionOrClassType }
-          }
-        ];
-        const returnType = validateCallArguments(
-          node.expression,
-          argList,
-          decoratorTypeResult,
-          /* typeVarContext */
-          void 0,
-          /* skipUnknownArgCheck */
-          true
-        ).returnType || types_1.UnknownType.create();
-        if ((0, types_1.isFunction)(returnType) && !returnType.details.declaredReturnType) {
-          if (!returnType.details.parameters.some((param, index) => {
-            if (!param.name || param.hasDeclaredType) {
-              return true;
-            }
-            if (param.category !== 0) {
-              return false;
-            }
-            return index !== 0 || !param.isTypeInferred;
-          })) {
-            return functionOrClassType;
-          }
-        }
-        if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
-          if ((0, types_1.isFunction)(decoratorTypeResult.type)) {
-            if (!decoratorTypeResult.type.details.parameters.find((param) => param.typeAnnotation !== void 0) && decoratorTypeResult.type.details.declaredReturnType === void 0) {
-              return functionOrClassType;
-            }
-          }
-        }
-        return returnType;
-      }
       function canBeFalsy(type, recursionCount = 0) {
         type = makeTopLevelTypeVarsConcrete(type);
         if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -52443,15 +52989,6 @@ var require_typeEvaluator = __commonJS({
             bindToType
           );
         }
-        if (memberInfo && memberInfo.classType && memberInfo.symbol && (0, types_1.isClass)(memberInfo.classType) && types_1.ClassType.isProtocolClass(memberInfo.classType)) {
-          const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(memberInfo.symbol);
-          if (primaryDecl && primaryDecl.type === 1 && !memberInfo.isClassVar) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.protocolMemberNotClassVar().format({
-              memberName,
-              className: memberInfo.classType.details.name
-            }), errorNode);
-          }
-        }
         const isMemberPresentOnClass = (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.classType) !== void 0;
         if (!memberInfo) {
           const metaclass = classType.details.effectiveMetaclass;
@@ -56212,7 +56749,7 @@ var require_typeEvaluator = __commonJS({
         }
         return typeResult;
       }
-      function getTypeOfTuple(node, inferenceContext, flags) {
+      function getTypeOfTuple(node, flags, inferenceContext) {
         if ((flags & 128) !== 0 && node.expressions.length === 0 && !inferenceContext) {
           return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
         }
@@ -56359,7 +56896,7 @@ var require_typeEvaluator = __commonJS({
         }
         return entryTypes;
       }
-      function getTypeOfCall(node, inferenceContext, flags) {
+      function getTypeOfCall(node, flags, inferenceContext) {
         var _a;
         let baseTypeResult;
         if (node.leftExpression.nodeType === 30) {
@@ -57152,8 +57689,8 @@ var require_typeEvaluator = __commonJS({
                 if (expandedSubtype.overloads[0].details.builtInName === "cast" && argList.length === 2) {
                   const castToType = getTypeOfArgumentExpectingType(argList[0]).type;
                   const castFromType = getTypeOfArgument(argList[1]).type;
-                  if ((0, types_1.isInstantiableClass)(castToType) && (0, types_1.isClassInstance)(castFromType)) {
-                    if ((0, types_1.isTypeSame)(castToType, types_1.ClassType.cloneAsInstantiable(castFromType), {
+                  if (types_1.TypeBase.isInstantiable(castToType) && !(0, types_1.isUnknown)(castToType)) {
+                    if ((0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(castToType), castFromType, {
                       ignorePseudoGeneric: true
                     })) {
                       addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUnnecessaryCast, diagnosticRules_1.DiagnosticRule.reportUnnecessaryCast, localize_1.Localizer.Diagnostic.unnecessaryCast().format({
@@ -57715,7 +58252,7 @@ var require_typeEvaluator = __commonJS({
           let unpackedDictionaryArgType;
           while (argIndex < argList.length) {
             if (argList[argIndex].argumentCategory === 2) {
-              const argType = getTypeOfArgument(argList[argIndex]).type;
+              const argType = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType)).type;
               if ((0, types_1.isAnyOrUnknown)(argType)) {
                 unpackedDictionaryArgType = argType;
               } else if ((0, types_1.isClassInstance)(argType) && types_1.ClassType.isTypedDictClass(argType)) {
@@ -58336,6 +58873,9 @@ var require_typeEvaluator = __commonJS({
         return returnType;
       }
       function validateFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
+        var _a;
+        const signatureTracker = (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker) !== null && _a !== void 0 ? _a : new typeUtils_1.UniqueSignatureTracker();
+        typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, signatureTracker, errorNode.start);
         const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, typeResult, 0);
         if (matchResults.argumentErrors) {
           argList.forEach((arg) => {
@@ -58349,7 +58889,7 @@ var require_typeEvaluator = __commonJS({
             overloadsUsedForCall: []
           };
         }
-        return validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
+        return validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, (0, typeUtils_1.makeInferenceContext)(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete, signatureTracker));
       }
       function validateFunctionArgumentsForParamSpec(errorNode, argList, paramSpec, destTypeVarContext, conditionFilter) {
         const signatureContexts = destTypeVarContext.getSignatureContexts();
@@ -58527,7 +59067,7 @@ var require_typeEvaluator = __commonJS({
           if (argParam.argType) {
             argType = argParam.argType;
           } else {
-            const flags = argParam.isinstanceParam ? 512 | 8 | 32 | 64 : 0;
+            const flags = argParam.isinstanceParam ? 512 | 8 | 32 | 64 : 2;
             const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
             argType = exprTypeResult.type;
             argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker, argParam.argument.valueExpression.start);
@@ -58563,16 +59103,6 @@ var require_typeEvaluator = __commonJS({
         } else {
           if (argParam.argType) {
             argType = argParam.argType;
-          } else if (argParam.isinstanceParam && !argParam.argument.typeResult && argParam.argument.valueExpression) {
-            const argTypeResult = getTypeOfExpression(
-              argParam.argument.valueExpression,
-              8 | 32 | 64
-              /* DisallowTypeVarTuple */
-            );
-            argType = argTypeResult.type;
-            if (argTypeResult.isIncomplete) {
-              isTypeIncomplete = true;
-            }
           } else {
             const argTypeResult = getTypeOfArgument(argParam.argument);
             argType = argTypeResult.type;
@@ -59037,7 +59567,7 @@ var require_typeEvaluator = __commonJS({
             let entryType = getTypeOfExpression(
               expr,
               128
-              /* ExpectingType */
+              /* ExpectingInstantiableType */
             ).type;
             if ((0, types_1.isTypeVar)(entryType)) {
               if (entryType.scopeId) {
@@ -59067,7 +59597,7 @@ var require_typeEvaluator = __commonJS({
           valueExpr,
           /* typeParamNodes */
           void 0,
-          () => typeParameters
+          () => typeParameters !== null && typeParameters !== void 0 ? typeParameters : []
         );
       }
       function getBooleanValue(node) {
@@ -59981,15 +60511,20 @@ var require_typeEvaluator = __commonJS({
         }
         const expectedFunctionType = expectedFunctionTypes.length > 0 ? expectedFunctionTypes[0] : void 0;
         let paramsArePositionOnly = true;
+        const expectedParamDetails = expectedFunctionType ? (0, parameterUtils_1.getParameterListDetails)(expectedFunctionType) : void 0;
         node.parameters.forEach((param, index) => {
-          let paramType = types_1.UnknownType.create();
-          if (expectedFunctionType && index < expectedFunctionType.details.parameters.length) {
-            paramType = types_1.FunctionType.getEffectiveParameterType(expectedFunctionType, index);
+          let paramType;
+          if (expectedParamDetails) {
+            if (index < expectedParamDetails.params.length) {
+              paramType = expectedParamDetails.params[index].type;
+            } else if (param.defaultValue) {
+              paramType = getTypeOfExpression(param.defaultValue, void 0, inferenceContext).type;
+            }
           }
           if (param.name) {
             writeTypeCache(
               param.name,
-              { type: transformVariadicParamType(node, param.category, paramType) },
+              { type: transformVariadicParamType(node, param.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create()) },
               0
               /* None */
             );
@@ -60026,7 +60561,7 @@ var require_typeEvaluator = __commonJS({
             hasDefault: !!param.defaultValue,
             defaultValueExpression: param.defaultValue,
             hasDeclaredType: true,
-            type: paramType
+            type: paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create()
           };
           types_1.FunctionType.addParameter(functionType, functionParam);
         });
@@ -60310,11 +60845,13 @@ var require_typeEvaluator = __commonJS({
                 hasDeclaredType: true
               });
             });
-            types_1.FunctionType.addParameter(functionType, {
-              category: 0,
-              isNameSynthesized: false,
-              type: types_1.UnknownType.create()
-            });
+            if (typeList.length > 0) {
+              types_1.FunctionType.addParameter(functionType, {
+                category: 0,
+                isNameSynthesized: false,
+                type: types_1.UnknownType.create()
+              });
+            }
           } else if ((0, typeUtils_1.isEllipsisType)(typeArgs[0].type)) {
             types_1.FunctionType.addDefaultParameters(functionType);
             functionType.details.flags |= 32768;
@@ -60544,7 +61081,8 @@ var require_typeEvaluator = __commonJS({
         }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(errorNode);
         if (enclosingFunction) {
-          const functionFlags = getFunctionFlagsFromDecorators(
+          const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(
+            evaluatorInterface,
             enclosingFunction,
             /* isInClass */
             true
@@ -61653,7 +62191,7 @@ var require_typeEvaluator = __commonJS({
         let foundUnknown = false;
         for (let i = node.decorators.length - 1; i >= 0; i--) {
           const decorator = node.decorators[i];
-          const newDecoratedType = applyClassDecorator(decoratedType, classType, decorator);
+          const newDecoratedType = (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator);
           const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(
             newDecoratedType,
             /* recurse */
@@ -61919,91 +62457,6 @@ var require_typeEvaluator = __commonJS({
           addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarsNotInGenericOrProtocol() + diag.getString(), errorNode);
         }
       }
-      function applyClassDecorator(inputClassType, originalClassType, decoratorNode) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(decoratorNode);
-        let flags = fileInfo.isStubFile ? 4 : 0;
-        if (decoratorNode.expression.nodeType !== 9) {
-          flags |= 2;
-        }
-        const decoratorType = getTypeOfExpression(decoratorNode.expression, flags).type;
-        if (decoratorNode.expression.nodeType === 9) {
-          const decoratorCallType = getTypeOfExpression(
-            decoratorNode.expression.leftExpression,
-            flags | 2
-            /* DoNotSpecialize */
-          ).type;
-          if ((0, types_1.isFunction)(decoratorCallType)) {
-            if (decoratorCallType.details.name === "__dataclass_transform__" || decoratorCallType.details.builtInName === "dataclass_transform") {
-              originalClassType.details.classDataClassTransform = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
-            } else if (decoratorCallType.details.builtInName === "deprecated") {
-              originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-              return inputClassType;
-            }
-          }
-          if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
-            if (decoratorCallType.overloads.length > 0 && decoratorCallType.overloads[0].details.builtInName === "deprecated") {
-              originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-              return inputClassType;
-            }
-          }
-        }
-        if ((0, types_1.isOverloadedFunction)(decoratorType)) {
-          const dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType);
-          if (dataclassBehaviors) {
-            (0, dataClasses_1.applyDataClassDecorator)(
-              evaluatorInterface,
-              decoratorNode,
-              originalClassType,
-              dataclassBehaviors,
-              /* callNode */
-              void 0
-            );
-            return inputClassType;
-          }
-          if (decoratorType.overloads.length > 0 && decoratorType.overloads[0].details.builtInName === "deprecated") {
-            originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-            return inputClassType;
-          }
-        } else if ((0, types_1.isFunction)(decoratorType)) {
-          if (decoratorType.details.builtInName === "final") {
-            originalClassType.details.flags |= 4096;
-            return inputClassType;
-          }
-          if (decoratorType.details.builtInName === "deprecated") {
-            originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-            return inputClassType;
-          }
-          if (decoratorType.details.builtInName === "runtime_checkable") {
-            originalClassType.details.flags |= 32768;
-            return inputClassType;
-          }
-          let dataclassBehaviors;
-          let callNode;
-          if (decoratorNode.expression.nodeType === 9) {
-            callNode = decoratorNode.expression;
-            const decoratorCallType = getTypeOfExpression(
-              callNode.leftExpression,
-              flags | 2
-              /* DoNotSpecialize */
-            ).type;
-            dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorCallType);
-          } else {
-            const decoratorType2 = getTypeOfExpression(decoratorNode.expression, flags).type;
-            dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType2);
-          }
-          if (dataclassBehaviors) {
-            (0, dataClasses_1.applyDataClassDecorator)(evaluatorInterface, decoratorNode, originalClassType, dataclassBehaviors, callNode);
-            return inputClassType;
-          }
-        }
-        return getTypeOfDecorator(decoratorNode, inputClassType);
-      }
-      function getCustomDeprecationMessage(decorator) {
-        if (decorator.expression.nodeType === 9 && decorator.expression.arguments.length > 0 && decorator.expression.arguments[0].argumentCategory === 0 && decorator.expression.arguments[0].valueExpression.nodeType === 48 && decorator.expression.arguments[0].valueExpression.strings.length === 1) {
-          return decorator.expression.arguments[0].valueExpression.strings[0].value;
-        }
-        return "";
-      }
       function runClassTypeHooks(type) {
         classTypeHooks.forEach((hook) => {
           if (types_1.ClassType.isSameGenericClass(hook.dependency, type)) {
@@ -62157,7 +62610,7 @@ var require_typeEvaluator = __commonJS({
           }
           containingClassType = classInfo.classType;
         }
-        let functionFlags = getFunctionFlagsFromDecorators(node, !!containingClassNode);
+        let functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, node, !!containingClassNode);
         if (functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.isGenerator) {
           functionFlags |= 16;
         }
@@ -62432,7 +62885,7 @@ var require_typeEvaluator = __commonJS({
         let foundUnknown = false;
         for (let i = node.decorators.length - 1; i >= 0; i--) {
           const decorator = node.decorators[i];
-          const newDecoratedType = applyFunctionDecorator(decoratedType, functionType, decorator, node);
+          const newDecoratedType = (0, decorators_1.applyFunctionDecorator)(evaluatorInterface, decoratedType, functionType, decorator, node);
           const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(
             newDecoratedType,
             /* recurse */
@@ -62453,7 +62906,7 @@ var require_typeEvaluator = __commonJS({
               markParamAccessed(param);
             });
           }
-          decoratedType = addOverloadsToFunctionType(node, decoratedType);
+          decoratedType = (0, decorators_1.addOverloadsToFunctionType)(evaluatorInterface, node, decoratedType);
         }
         writeTypeCache(
           node.name,
@@ -62525,6 +62978,10 @@ var require_typeEvaluator = __commonJS({
                 const baseClassParamAnnotation = (_a = baseClassParam.typeAnnotation) !== null && _a !== void 0 ? _a : baseClassParam.typeAnnotationComment;
                 if (baseClassParamAnnotation) {
                   let inferredParamType = getTypeOfParameterAnnotation(baseClassParamAnnotation, functionNode.parameters[paramIndex].category);
+                  if ((0, typeUtils_1.requiresSpecialization)(inferredParamType) && (0, types_1.isClass)(baseClassMemberInfo.classType)) {
+                    const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClassMemberInfo.classType);
+                    inferredParamType = (0, typeUtils_1.applySolvedTypeVars)(inferredParamType, typeVarContext);
+                  }
                   const fileInfo = AnalyzerNodeInfo.getFileInfo(functionNode);
                   if (fileInfo.isInPyTypedPackage && !fileInfo.isStubFile) {
                     inferredParamType = types_1.TypeBase.cloneForAmbiguousType(inferredParamType);
@@ -62613,227 +63070,6 @@ var require_typeEvaluator = __commonJS({
           }
         }
       }
-      function getFunctionFlagsFromDecorators(node, isInClass) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        let flags = 0;
-        if (isInClass) {
-          if (node.name.value === "__new__") {
-            flags |= 1;
-          }
-          const implicitClassMethods = ["__init_subclass__", "__class_getitem__"];
-          if (implicitClassMethods.some((name) => node.name.value === name)) {
-            flags |= 2;
-          }
-        }
-        for (const decoratorNode of node.decorators) {
-          let evaluatorFlags = fileInfo.isStubFile ? 4 : 0;
-          if (decoratorNode.expression.nodeType !== 9) {
-            evaluatorFlags |= 2;
-          }
-          const decoratorTypeResult = getTypeOfExpression(decoratorNode.expression, evaluatorFlags);
-          const decoratorType = decoratorTypeResult.type;
-          if ((0, types_1.isFunction)(decoratorType)) {
-            if (decoratorType.details.builtInName === "abstractmethod") {
-              if (isInClass) {
-                flags |= 8;
-              }
-            } else if (decoratorType.details.builtInName === "final") {
-              flags |= 8192;
-            } else if (decoratorType.details.builtInName === "override") {
-              flags |= 262144;
-            }
-          } else if ((0, types_1.isInstantiableClass)(decoratorType)) {
-            if (types_1.ClassType.isBuiltIn(decoratorType, "staticmethod")) {
-              if (isInClass) {
-                flags |= 4;
-              }
-            } else if (types_1.ClassType.isBuiltIn(decoratorType, "classmethod")) {
-              if (isInClass) {
-                flags |= 2;
-              }
-            }
-          }
-        }
-        return flags;
-      }
-      function applyFunctionDecorator(inputFunctionType, undecoratedType, decoratorNode, functionNode) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(decoratorNode);
-        let evaluatorFlags = fileInfo.isStubFile ? 4 : 0;
-        if (decoratorNode.expression.nodeType !== 9) {
-          evaluatorFlags |= 2;
-        }
-        const decoratorTypeResult = getTypeOfExpression(decoratorNode.expression, evaluatorFlags);
-        const decoratorType = decoratorTypeResult.type;
-        if ((0, types_1.isInstantiableClass)(decoratorType) && types_1.ClassType.isSpecialBuiltIn(decoratorType, "overload") || (0, types_1.isFunction)(decoratorType) && decoratorType.details.builtInName === "overload") {
-          if ((0, types_1.isFunction)(inputFunctionType)) {
-            inputFunctionType.details.flags |= 256;
-            undecoratedType.details.flags |= 256;
-            return inputFunctionType;
-          }
-        }
-        if (decoratorNode.expression.nodeType === 9) {
-          const decoratorCallType = getTypeOfExpression(
-            decoratorNode.expression.leftExpression,
-            evaluatorFlags | 2
-            /* DoNotSpecialize */
-          ).type;
-          if ((0, types_1.isFunction)(decoratorCallType)) {
-            if (decoratorCallType.details.name === "__dataclass_transform__" || decoratorCallType.details.builtInName === "dataclass_transform") {
-              undecoratedType.details.decoratorDataClassBehaviors = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
-              return inputFunctionType;
-            }
-            if (decoratorCallType.details.builtInName === "deprecated") {
-              undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-              return inputFunctionType;
-            }
-          }
-          if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
-            if (decoratorCallType.overloads.length > 0 && decoratorCallType.overloads[0].details.builtInName === "deprecated") {
-              undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-              return inputFunctionType;
-            }
-          }
-        }
-        let returnType = getTypeOfDecorator(decoratorNode, inputFunctionType);
-        if ((0, types_1.isFunction)(decoratorType)) {
-          if (decoratorType.details.builtInName === "abstractmethod") {
-            return inputFunctionType;
-          }
-          if (decoratorType.details.builtInName === "deprecated") {
-            undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-            return inputFunctionType;
-          }
-          if (decoratorNode.expression.nodeType === 35) {
-            const baseType = getTypeOfExpression(
-              decoratorNode.expression.leftExpression,
-              evaluatorFlags | 2
-              /* DoNotSpecialize */
-            ).type;
-            if ((0, typeUtils_1.isProperty)(baseType)) {
-              const memberName = decoratorNode.expression.memberName.value;
-              if (memberName === "setter") {
-                if ((0, types_1.isFunction)(inputFunctionType)) {
-                  (0, properties_1.validatePropertyMethod)(evaluatorInterface, inputFunctionType, decoratorNode);
-                  return (0, properties_1.clonePropertyWithSetter)(evaluatorInterface, baseType, inputFunctionType, functionNode);
-                } else {
-                  return inputFunctionType;
-                }
-              } else if (memberName === "deleter") {
-                if ((0, types_1.isFunction)(inputFunctionType)) {
-                  (0, properties_1.validatePropertyMethod)(evaluatorInterface, inputFunctionType, decoratorNode);
-                  return (0, properties_1.clonePropertyWithDeleter)(evaluatorInterface, baseType, inputFunctionType, functionNode);
-                } else {
-                  return inputFunctionType;
-                }
-              }
-            }
-          }
-        } else if ((0, types_1.isOverloadedFunction)(decoratorType)) {
-          if (decoratorType.overloads.length > 0 && decoratorType.overloads[0].details.builtInName === "deprecated") {
-            undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-            return inputFunctionType;
-          }
-        } else if ((0, types_1.isInstantiableClass)(decoratorType)) {
-          if (types_1.ClassType.isBuiltIn(decoratorType)) {
-            switch (decoratorType.details.name) {
-              case "classmethod":
-              case "staticmethod": {
-                const requiredFlag = decoratorType.details.name === "classmethod" ? 2 : 4;
-                if ((0, types_1.isFunction)(inputFunctionType) && (inputFunctionType.details.flags & requiredFlag) === 0) {
-                  const newFunction = types_1.FunctionType.clone(inputFunctionType);
-                  newFunction.details.flags &= ~(1 | 4 | 2);
-                  newFunction.details.flags |= requiredFlag;
-                  return newFunction;
-                }
-                return inputFunctionType;
-              }
-            }
-          }
-          if (types_1.ClassType.isPropertyClass(decoratorType)) {
-            if ((0, types_1.isFunction)(inputFunctionType)) {
-              (0, properties_1.validatePropertyMethod)(evaluatorInterface, inputFunctionType, decoratorNode);
-              return (0, properties_1.createProperty)(evaluatorInterface, decoratorNode, decoratorType, inputFunctionType);
-            } else if ((0, types_1.isClassInstance)(inputFunctionType)) {
-              const boundMethod = getBoundMethod(inputFunctionType, "__call__");
-              if (boundMethod && (0, types_1.isFunction)(boundMethod)) {
-                return (0, properties_1.createProperty)(evaluatorInterface, decoratorNode, decoratorType, boundMethod);
-              }
-              return types_1.UnknownType.create();
-            }
-          }
-        }
-        if ((0, types_1.isFunction)(inputFunctionType) && (0, types_1.isFunction)(returnType)) {
-          returnType = types_1.FunctionType.clone(returnType);
-          if (types_1.FunctionType.isOverloaded(inputFunctionType)) {
-            returnType.details.flags |= 256;
-          }
-          if (!returnType.details.docString) {
-            returnType.details.docString = inputFunctionType.details.docString;
-          }
-        }
-        return returnType;
-      }
-      function addOverloadsToFunctionType(node, type) {
-        let functionDecl;
-        const decl = AnalyzerNodeInfo.getDeclaration(node);
-        if (decl) {
-          functionDecl = decl;
-        }
-        const symbolWithScope = lookUpSymbolRecursive(
-          node,
-          node.name.value,
-          /* honorCodeFlow */
-          false
-        );
-        if (symbolWithScope) {
-          const decls = symbolWithScope.symbol.getDeclarations();
-          const declIndex = decls.findIndex((decl2) => decl2 === functionDecl);
-          if (declIndex > 0) {
-            for (let i = 0; i < declIndex; i++) {
-              const decl2 = decls[i];
-              if (decl2.type === 5) {
-                getTypeOfFunction(decl2.node);
-              }
-            }
-            let overloadedTypes = [];
-            const prevDecl = decls[declIndex - 1];
-            if (prevDecl.type === 5) {
-              const prevDeclDeclTypeInfo = getTypeOfFunction(prevDecl.node);
-              if (prevDeclDeclTypeInfo) {
-                if ((0, types_1.isFunction)(prevDeclDeclTypeInfo.decoratedType)) {
-                  if (types_1.FunctionType.isOverloaded(prevDeclDeclTypeInfo.decoratedType)) {
-                    overloadedTypes.push(prevDeclDeclTypeInfo.decoratedType);
-                  }
-                } else if ((0, types_1.isOverloadedFunction)(prevDeclDeclTypeInfo.decoratedType)) {
-                  (0, collectionUtils_1.appendArray)(overloadedTypes, prevDeclDeclTypeInfo.decoratedType.overloads);
-                }
-              }
-            }
-            overloadedTypes.push(type);
-            if (overloadedTypes.length === 1) {
-              return overloadedTypes[0];
-            }
-            const implementation = overloadedTypes.find((signature) => !types_1.FunctionType.isOverloaded(signature));
-            if (implementation === null || implementation === void 0 ? void 0 : implementation.details.docString) {
-              overloadedTypes = overloadedTypes.map((overload) => {
-                if (types_1.FunctionType.isOverloaded(overload) && !overload.details.docString) {
-                  return types_1.FunctionType.cloneWithDocString(overload, implementation.details.docString);
-                }
-                return overload;
-              });
-            }
-            const newOverload = types_1.OverloadedFunctionType.create(overloadedTypes);
-            const prevOverload = overloadedTypes[overloadedTypes.length - 2];
-            const isPrevOverloadAbstract = types_1.FunctionType.isAbstractMethod(prevOverload);
-            const isCurrentOverloadAbstract = types_1.FunctionType.isAbstractMethod(type);
-            if (isPrevOverloadAbstract !== isCurrentOverloadAbstract) {
-              addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadAbstractMismatch().format({ name: node.name.value }), node.name);
-            }
-            return newOverload;
-          }
-        }
-        return type;
-      }
       function createAsyncFunction(node, functionType) {
         const awaitableFunctionType = types_1.FunctionType.clone(functionType);
         if (functionType.details.declaredReturnType) {
@@ -63765,7 +64001,8 @@ var require_typeEvaluator = __commonJS({
             return;
           }
         }
-        const functionFlags = getFunctionFlagsFromDecorators(
+        const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(
+          evaluatorInterface,
           functionNode,
           /* isInClass */
           true
@@ -64232,14 +64469,19 @@ var require_typeEvaluator = __commonJS({
         const specializedClass = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== void 0);
         return { type: specializedClass };
       }
-      function getTypeOfArgument(arg) {
+      function getTypeOfArgument(arg, inferenceContext) {
         if (arg.typeResult) {
           return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
         }
         if (!arg.valueExpression) {
           return { type: types_1.UnknownType.create() };
         }
-        return getTypeOfExpression(arg.valueExpression);
+        return getTypeOfExpression(
+          arg.valueExpression,
+          /* flags */
+          void 0,
+          inferenceContext
+        );
       }
       function getTypeOfArgumentExpectingType(arg) {
         if (arg.typeResult) {
@@ -65590,43 +65832,47 @@ var require_typeEvaluator = __commonJS({
         let isAssignable = true;
         destType.details.fields.forEach((symbol, name) => {
           var _a;
-          if (isAssignable && symbol.isClassMember() && !symbol.isIgnoredForProtocolMatch()) {
-            const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
-            (0, debug_1.assert)(memberInfo !== void 0);
-            let destMemberType = (_a = getDeclaredTypeOfSymbol(symbol)) === null || _a === void 0 ? void 0 : _a.type;
-            if (destMemberType) {
-              const srcMemberType = getTypeOfMember(memberInfo);
-              destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
-              if ((0, types_1.isClassInstance)(destMemberType) && types_1.ClassType.isPropertyClass(destMemberType) && (0, types_1.isClassInstance)(srcMemberType) && types_1.ClassType.isPropertyClass(srcMemberType)) {
-                if (!(0, properties_1.assignProperty)(
-                  evaluatorInterface,
-                  types_1.ClassType.cloneAsInstantiable(destMemberType),
-                  types_1.ClassType.cloneAsInstantiable(srcMemberType),
-                  destType,
-                  srcType,
-                  diag,
-                  typeVarContext,
-                  /* selfTypeVarContext */
-                  void 0,
-                  recursionCount
-                )) {
-                  isAssignable = false;
-                }
-              } else {
-                const primaryDecl = symbol.getDeclarations()[0];
-                const flags = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 && !isFinalVariableDeclaration(primaryDecl) ? 1 : 0;
-                if (!assignType(
-                  destMemberType,
-                  srcMemberType,
-                  diag,
-                  typeVarContext,
-                  /* srcTypeVarContext */
-                  void 0,
-                  flags,
-                  recursionCount
-                )) {
-                  isAssignable = false;
-                }
+          if (!isAssignable || !symbol.isClassMember() || symbol.isIgnoredForProtocolMatch()) {
+            return;
+          }
+          if (name === "__new__" || name === "__init__") {
+            return;
+          }
+          const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
+          (0, debug_1.assert)(memberInfo !== void 0);
+          let destMemberType = (_a = getDeclaredTypeOfSymbol(symbol)) === null || _a === void 0 ? void 0 : _a.type;
+          if (destMemberType) {
+            const srcMemberType = getTypeOfMember(memberInfo);
+            destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
+            if ((0, types_1.isClassInstance)(destMemberType) && types_1.ClassType.isPropertyClass(destMemberType) && (0, types_1.isClassInstance)(srcMemberType) && types_1.ClassType.isPropertyClass(srcMemberType)) {
+              if (!(0, properties_1.assignProperty)(
+                evaluatorInterface,
+                types_1.ClassType.cloneAsInstantiable(destMemberType),
+                types_1.ClassType.cloneAsInstantiable(srcMemberType),
+                destType,
+                srcType,
+                diag,
+                typeVarContext,
+                /* selfTypeVarContext */
+                void 0,
+                recursionCount
+              )) {
+                isAssignable = false;
+              }
+            } else {
+              const primaryDecl = symbol.getDeclarations()[0];
+              const flags = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 && !isFinalVariableDeclaration(primaryDecl) ? 1 : 0;
+              if (!assignType(
+                destMemberType,
+                srcMemberType,
+                diag,
+                typeVarContext,
+                /* srcTypeVarContext */
+                void 0,
+                flags,
+                recursionCount
+              )) {
+                isAssignable = false;
               }
             }
           }
@@ -65708,7 +65954,7 @@ var require_typeEvaluator = __commonJS({
           }
         }
       }
-      function assignTupleTypeArgs(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+      function assignTupleTypeArguments(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b;
         const destTypeArgs = [...(_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : []];
         const srcTypeArgs = [...(_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : []];
@@ -65746,25 +65992,23 @@ var require_typeEvaluator = __commonJS({
       function assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         let curSrcType = srcType;
         let prevSrcType;
-        let curDestTypeVarContext = destTypeVarContext;
-        let effectiveFlags = flags;
         inferTypeParameterVarianceForClass(destType);
-        effectiveFlags |= 8;
-        if (!destTypeVarContext) {
-          curDestTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType));
-          effectiveFlags &= ~8;
+        if ((flags & 1) !== 0) {
+          const srcIsLiteral = srcType.literalValue !== void 0;
+          const destIsLiteral = destType.literalValue !== void 0;
+          if (srcIsLiteral !== destIsLiteral) {
+            return false;
+          }
         } else {
-          effectiveFlags |= 8;
+          if (types_1.ClassType.isBuiltIn(destType, "object")) {
+            return true;
+          }
         }
         for (let ancestorIndex = inheritanceChain.length - 1; ancestorIndex >= 0; ancestorIndex--) {
           const ancestorType = inheritanceChain[ancestorIndex];
-          const curSrcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(curSrcType));
           if ((0, types_1.isUnknown)(ancestorType)) {
             return true;
           }
-          if (types_1.ClassType.isBuiltIn(ancestorType, "object")) {
-            return true;
-          }
           if (ancestorIndex < inheritanceChain.length - 1) {
             let effectiveCurSrcType = curSrcType;
             if (types_1.ClassType.isBuiltIn(curSrcType, "NamedTuple") && types_1.ClassType.isBuiltIn(ancestorType, "tuple") && prevSrcType) {
@@ -65772,9 +66016,6 @@ var require_typeEvaluator = __commonJS({
             }
             curSrcType = (0, typeUtils_1.specializeForBaseClass)(effectiveCurSrcType, ancestorType);
           }
-          if (ancestorIndex === 0 && destType.tupleTypeArguments && curSrcType.tupleTypeArguments) {
-            return assignTupleTypeArgs(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
-          }
           const ancestorTypeParams = types_1.ClassType.getTypeParameters(ancestorType);
           if (ancestorTypeParams.length === 0) {
             continue;
@@ -65782,11 +66023,6 @@ var require_typeEvaluator = __commonJS({
           if (!ancestorType.typeArguments) {
             return true;
           }
-          if (!verifyTypeArgumentsAssignable(ancestorType, curSrcType, diag, curDestTypeVarContext, curSrcTypeVarContext, effectiveFlags, recursionCount)) {
-            return false;
-          }
-          curDestTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(ancestorType));
-          effectiveFlags &= ~8;
           prevSrcType = curSrcType;
         }
         if ((flags & 1) !== 0) {
@@ -65796,11 +66032,13 @@ var require_typeEvaluator = __commonJS({
             return false;
           }
         }
+        if (destType.tupleTypeArguments && curSrcType.tupleTypeArguments) {
+          return assignTupleTypeArguments(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+        }
         if (destType.typeArguments) {
-          if (!verifyTypeArgumentsAssignable(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-            return false;
-          }
-        } else if (destTypeVarContext && destType.details.typeParameters.length > 0 && curSrcType.typeArguments && !destTypeVarContext.isLocked()) {
+          return assignTypeArguments(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+        }
+        if (destTypeVarContext && curSrcType.typeArguments && !destTypeVarContext.isLocked()) {
           const srcTypeArgs = curSrcType.typeArguments;
           for (let i = 0; i < destType.details.typeParameters.length; i++) {
             const typeArgType = i < srcTypeArgs.length ? srcTypeArgs[i] : types_1.UnknownType.create();
@@ -65835,7 +66073,7 @@ var require_typeEvaluator = __commonJS({
         }
         return void 0;
       }
-      function verifyTypeArgumentsAssignable(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+      function assignTypeArguments(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b, _c;
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
         inferTypeParameterVarianceForClass(destType);
@@ -65887,7 +66125,7 @@ var require_typeEvaluator = __commonJS({
                 isCompatible = false;
               }
             } else {
-              if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 1, recursionCount)) {
+              if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 1 | 128, recursionCount)) {
                 if (!types_1.ClassType.isPseudoGenericClass(destType)) {
                   if (diag) {
                     const childDiag = diag.createAddendum();
@@ -66357,7 +66595,7 @@ var require_typeEvaluator = __commonJS({
             return true;
           }
           if ((0, types_1.isFunction)(concreteSrcType)) {
-            if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(concreteSrcType)), flags, recursionCount)) {
+            if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(concreteSrcType)), flags, recursionCount)) {
               return true;
             }
           }
@@ -67813,7 +68051,7 @@ var require_typeEvaluator = __commonJS({
                 let isAbstract;
                 const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
                 if (decl && decl.type === 5) {
-                  const functionFlags = getFunctionFlagsFromDecorators(decl.node, true);
+                  const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, decl.node, true);
                   isAbstract = !!(functionFlags & 8);
                 } else {
                   isAbstract = false;
@@ -67939,7 +68177,7 @@ var require_typeEvaluator = __commonJS({
             typeVarContext,
             /* srcTypeVarContext */
             void 0,
-            0,
+            2048,
             recursionCount
           )) {
             if (memberTypeFirstParam.name && !memberTypeFirstParam.isNameSynthesized && memberTypeFirstParam.hasDeclaredType) {
@@ -68031,6 +68269,9 @@ var require_typeEvaluator = __commonJS({
         if (options === null || options === void 0 ? void 0 : options.printUnknownWithAny) {
           flags |= 1;
         }
+        if (options === null || options === void 0 ? void 0 : options.printTypeVarVariance) {
+          flags |= 2048;
+        }
         if (options === null || options === void 0 ? void 0 : options.omitTypeArgumentsIfUnknown) {
           flags |= 2;
         }
@@ -68169,7 +68410,7 @@ var require_typeEvaluator = __commonJS({
         getObjectType,
         getBuiltInObject,
         getTypingType,
-        verifyTypeArgumentsAssignable,
+        assignTypeArguments,
         reportMissingTypeArguments,
         inferReturnTypeIfNecessary,
         inferTypeParameterVarianceForClass,
@@ -97700,7 +97941,6 @@ var PythonFormattingEditProvider = class {
     const provider = this.pythonSettings.formatting.provider;
     const formatter = this.formatters.get(provider);
     if (!formatter) {
-      import_coc9.window.showWarningMessage(`No formatter is set. You need to set "python.formatting.provider" in your coc-settings.json`);
       this.outputChannel.appendLine(`${"#".repeat(10)} Error: python.formatting.provider is ${provider}, which is not supported`);
       return [];
     }