coc-pyright 1.1.303 → 1.1.304

package/lib/index.js

@@ -8892,7 +8892,11 @@ var require_parseTreeUtils = __commonJS({
           return printExpression(node.leftExpression, flags) + "." + node.memberName.value;
         }
         case 9: {
-          return printExpression(node.leftExpression, flags) + "(" + node.arguments.map((arg) => printArgument(arg, flags)).join(", ") + ")";
+          let lhs = printExpression(node.leftExpression, flags);
+          if (node.leftExpression.nodeType !== 35 && node.leftExpression.nodeType !== 38 && node.leftExpression.nodeType !== 24 && node.leftExpression.nodeType !== 9) {
+            lhs = `(${lhs})`;
+          }
+          return lhs + "(" + node.arguments.map((arg) => printArgument(arg, flags)).join(", ") + ")";
         }
         case 24: {
           return printExpression(node.baseExpression, flags) + "[" + node.items.map((item) => printArgument(item, flags)).join(", ") + (node.trailingComma ? "," : "") + "]";
@@ -22006,7 +22010,7 @@ var require_configOptions = __commonJS({
     function getOffDiagnosticRuleSet() {
       const diagSettings = {
         printUnknownAsAny: true,
-        omitTypeArgsIfAny: true,
+        omitTypeArgsIfUnknown: true,
         omitUnannotatedParamType: true,
         omitConditionalConstraint: true,
         pep604Printing: true,
@@ -22087,7 +22091,7 @@ var require_configOptions = __commonJS({
     function getBasicDiagnosticRuleSet() {
       const diagSettings = {
         printUnknownAsAny: false,
-        omitTypeArgsIfAny: false,
+        omitTypeArgsIfUnknown: false,
         omitUnannotatedParamType: true,
         omitConditionalConstraint: false,
         pep604Printing: true,
@@ -22168,7 +22172,7 @@ var require_configOptions = __commonJS({
     function getStrictDiagnosticRuleSet() {
       const diagSettings = {
         printUnknownAsAny: false,
-        omitTypeArgsIfAny: false,
+        omitTypeArgsIfUnknown: false,
         omitUnannotatedParamType: false,
         omitConditionalConstraint: false,
         pep604Printing: true,
@@ -23451,7 +23455,7 @@ var require_declarationUtils = __commonJS({
         if (!symbol) {
           if (curDeclaration.submoduleFallback) {
             if (curDeclaration.symbolName) {
-              if (curDeclaration.submoduleFallback.type === 8 && curDeclaration.submoduleFallback.path) {
+              if (curDeclaration.path && curDeclaration.submoduleFallback.type === 8 && curDeclaration.submoduleFallback.path) {
                 const lookupResult2 = importLookup(curDeclaration.submoduleFallback.path);
                 if (!lookupResult2) {
                   return void 0;
@@ -24376,11 +24380,11 @@ var require_types = __commonJS({
         return isIncomplete ? _incompleteInstance : _instance;
       }
       UnknownType2.create = create;
-      function createPossibleType(possibleType) {
+      function createPossibleType(possibleType, isIncomplete) {
         const unknownWithPossibleType = {
           category: 1,
           flags: 1 | 2,
-          isIncomplete: false,
+          isIncomplete,
           possibleType
         };
         return unknownWithPossibleType;
@@ -25009,6 +25013,13 @@ var require_types = __commonJS({
         return newFunction;
       }
       FunctionType2.cloneWithNewFlags = cloneWithNewFlags;
+      function cloneWithNewTypeVarScopeId(type, newScopeId) {
+        const newFunction = TypeBase.cloneType(type);
+        newFunction.details = { ...type.details };
+        newFunction.details.typeVarScopeId = newScopeId;
+        return newFunction;
+      }
+      FunctionType2.cloneWithNewTypeVarScopeId = cloneWithNewTypeVarScopeId;
       function cloneWithDocString(type, docString) {
         const newFunction = TypeBase.cloneType(type);
         newFunction.details = { ...type.details };
@@ -29017,10 +29028,10 @@ var require_typeUtils = __commonJS({
         const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
         if (typeVar.scopeId && this._typeVarContext.hasSolveForScope(typeVar.scopeId)) {
           let replacement = signatureContext.getTypeVarType(typeVar, !!this._options.useNarrowBoundOnly);
-          if (!replacement && !!this._options.useNarrowBoundOnly) {
+          if (!replacement && this._options.useNarrowBoundOnly) {
             const wideType = signatureContext.getTypeVarType(typeVar);
             if (wideType) {
-              if (containsLiteralType(
+              if ((0, types_1.isTypeVar)(wideType) || containsLiteralType(
                 wideType,
                 /* includeTypeArgs */
                 true
@@ -29899,7 +29910,7 @@ var require_sourceMapper = __commonJS({
         const filePath = type.details.filePath;
         const sourceFiles = this._getSourceFiles(
           filePath,
-          /*stubToShadow*/
+          /* stubToShadow */
           void 0,
           originated
         );
@@ -32857,7 +32868,7 @@ var require_typePrinter = __commonJS({
     (function(PrintTypeFlags2) {
       PrintTypeFlags2[PrintTypeFlags2["None"] = 0] = "None";
       PrintTypeFlags2[PrintTypeFlags2["PrintUnknownWithAny"] = 1] = "PrintUnknownWithAny";
-      PrintTypeFlags2[PrintTypeFlags2["OmitTypeArgumentsIfAny"] = 2] = "OmitTypeArgumentsIfAny";
+      PrintTypeFlags2[PrintTypeFlags2["OmitTypeArgumentsIfUnknown"] = 2] = "OmitTypeArgumentsIfUnknown";
       PrintTypeFlags2[PrintTypeFlags2["OmitUnannotatedParamType"] = 4] = "OmitUnannotatedParamType";
       PrintTypeFlags2[PrintTypeFlags2["PEP604"] = 8] = "PEP604";
       PrintTypeFlags2[PrintTypeFlags2["ParenthesizeUnion"] = 16] = "ParenthesizeUnion";
@@ -32896,7 +32907,7 @@ var require_typePrinter = __commonJS({
             if (typeParams) {
               let argumentStrings;
               if (type.typeAliasInfo.typeArguments) {
-                if ((printTypeFlags & 2) === 0 || type.typeAliasInfo.typeArguments.some((typeArg) => !(0, types_1.isAnyOrUnknown)(typeArg))) {
+                if ((printTypeFlags & 2) === 0 || type.typeAliasInfo.typeArguments.some((typeArg) => !(0, types_1.isUnknown)(typeArg))) {
                   argumentStrings = [];
                   type.typeAliasInfo.typeArguments.forEach((typeArg, index) => {
                     const typeParam = index < typeParams.length ? typeParams[index] : typeParams[typeParams.length - 1];
@@ -32910,7 +32921,7 @@ var require_typePrinter = __commonJS({
                   });
                 }
               } else {
-                if ((printTypeFlags & 2) === 0 || typeParams.some((typeParam) => !(0, types_1.isAnyOrUnknown)(typeParam))) {
+                if ((printTypeFlags & 2) === 0 || typeParams.some((typeParam) => !(0, types_1.isUnknown)(typeParam))) {
                   argumentStrings = [];
                   typeParams.forEach((typeParam) => {
                     argumentStrings.push(printType(typeParam, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount));
@@ -33189,7 +33200,10 @@ var require_typePrinter = __commonJS({
             }
           });
           if (type.details.paramSpec) {
-            return `Callable[Concatenate[${paramTypes.join(", ")}, ${type.details.paramSpec.details.name}], ${returnTypeString}]`;
+            if (paramTypes.length > 0) {
+              return `Callable[Concatenate[${paramTypes.join(", ")}, ${type.details.paramSpec.details.name}], ${returnTypeString}]`;
+            }
+            return `Callable[${type.details.paramSpec.details.name}, ${returnTypeString}]`;
           }
           return `Callable[[${paramTypes.join(", ")}], ${returnTypeString}]`;
         } else {
@@ -33271,21 +33285,21 @@ var require_typePrinter = __commonJS({
         if (typeArgs) {
           if (typeArgs.length > 0) {
             const typeArgStrings = [];
-            let isAllAny = true;
+            let isAllUnknown = true;
             typeArgs.forEach((typeArg, index) => {
               const typeParam = index < typeParams.length ? typeParams[index] : void 0;
               if (typeParam && typeParam.details.isVariadic && (0, types_1.isClassInstance)(typeArg.type) && types_1.ClassType.isBuiltIn(typeArg.type, "tuple") && typeArg.type.tupleTypeArguments) {
                 if (typeArg.type.tupleTypeArguments.length === 0) {
-                  if (!(0, types_1.isAnyOrUnknown)(typeArg.type)) {
-                    isAllAny = false;
+                  if (!(0, types_1.isUnknown)(typeArg.type)) {
+                    isAllUnknown = false;
                   }
                   if (index === 0) {
                     typeArgStrings.push(_printUnpack("tuple[()]", printTypeFlags));
                   }
                 } else {
                   typeArgStrings.push(...typeArg.type.tupleTypeArguments.map((typeArg2) => {
-                    if (!(0, types_1.isAnyOrUnknown)(typeArg2.type)) {
-                      isAllAny = false;
+                    if (!(0, types_1.isUnknown)(typeArg2.type)) {
+                      isAllUnknown = false;
                     }
                     const typeArgText = printType(typeArg2.type, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
                     if (typeArg2.isUnbounded) {
@@ -33295,8 +33309,8 @@ var require_typePrinter = __commonJS({
                   }));
                 }
               } else {
-                if (!(0, types_1.isAnyOrUnknown)(typeArg.type)) {
-                  isAllAny = false;
+                if (!(0, types_1.isUnknown)(typeArg.type)) {
+                  isAllUnknown = false;
                 }
                 const typeArgTypeText = printType(typeArg.type, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
                 if (typeArg.isUnbounded) {
@@ -33313,7 +33327,7 @@ var require_typePrinter = __commonJS({
             if (type.isUnpacked) {
               objName = _printUnpack(objName, printTypeFlags);
             }
-            if ((printTypeFlags & 2) === 0 || !isAllAny) {
+            if ((printTypeFlags & 2) === 0 || !isAllUnknown) {
               objName += "[" + typeArgStrings.join(", ") + "]";
             }
           } else {
@@ -33329,7 +33343,7 @@ var require_typePrinter = __commonJS({
             objName = _printUnpack(objName, printTypeFlags);
           }
           if (typeParams.length > 0) {
-            if ((printTypeFlags & 2) === 0 || typeParams.some((typeParam) => !(0, types_1.isAnyOrUnknown)(typeParam))) {
+            if ((printTypeFlags & 2) === 0 || typeParams.some((typeParam) => !(0, types_1.isUnknown)(typeParam))) {
               objName += "[" + typeParams.map((typeParam) => {
                 return printType(typeParam, printTypeFlags, returnTypeCallback, recursionTypes, recursionCount);
               }).join(", ") + "]";
@@ -34285,7 +34299,7 @@ var require_autoImporter = __commonJS({
       ImportFormat2["Absolute"] = "absolute";
       ImportFormat2["Relative"] = "relative";
     })(ImportFormat = exports.ImportFormat || (exports.ImportFormat = {}));
-    function buildModuleSymbolsMap(files, includeIndexUserSymbols, token) {
+    function buildModuleSymbolsMap(files, includeSymbolsFromIndices, token) {
       const moduleSymbolMap = /* @__PURE__ */ new Map();
       (0, cancellationUtils_1.throwIfCancellationRequested)(token);
       files.forEach((file) => {
@@ -34329,7 +34343,7 @@ var require_autoImporter = __commonJS({
           return;
         }
         const indexResults = file.sourceFile.getCachedIndexResults();
-        if (indexResults && includeIndexUserSymbols && !indexResults.privateOrProtected) {
+        if (indexResults && includeSymbolsFromIndices && !indexResults.privateOrProtected) {
           moduleSymbolMap.set(filePath, createModuleSymbolTableFromIndexResult(
             indexResults,
             /* library */
@@ -35086,7 +35100,20 @@ var require_completionProviderUtils = __commonJS({
               }
             }
           }
-          return name + ": " + evaluator.printType(type, { expandTypeAlias });
+          if (type.category === 6 || type.category === 5) {
+            return (0, tooltipUtils_1.getToolTipForType)(
+              type,
+              /* label */
+              "",
+              name,
+              evaluator,
+              /* isProperty */
+              false,
+              functionSignatureDisplay
+            );
+          } else {
+            return name + ": " + evaluator.printType(type, { expandTypeAlias });
+          }
         }
         case 5: {
           const functionType = (detail === null || detail === void 0 ? void 0 : detail.boundObjectOrClass) && ((0, types_1.isFunction)(type) || (0, types_1.isOverloadedFunction)(type)) ? evaluator.bindFunctionToClassOrObject(detail.boundObjectOrClass, type) : type;
@@ -35103,11 +35130,11 @@ var require_completionProviderUtils = __commonJS({
           }
           return (0, tooltipUtils_1.getToolTipForType)(
             functionType,
-            /*label*/
+            /* label */
             "",
             name,
             evaluator,
-            /*isProperty*/
+            /* isProperty */
             false,
             functionSignatureDisplay
           );
@@ -35258,7 +35285,7 @@ var require_documentSymbolCollector = __commonJS({
           useCase,
           evaluator,
           token,
-          /*skipUnreachableCode*/
+          /* skipUnreachableCode */
           false
         );
         let builtinsScope = AnalyzerNodeInfo.getFileInfo(node).builtinsScope;
@@ -36312,69 +36339,73 @@ var require_completionProvider = __commonJS({
         if (!classResults) {
           return void 0;
         }
-        const symbolTable = /* @__PURE__ */ new Map();
-        for (let i = 1; i < classResults.classType.details.mro.length; i++) {
-          const mroClass = classResults.classType.details.mro[i];
-          if ((0, types_1.isInstantiableClass)(mroClass)) {
-            (0, typeUtils_1.getMembersForClass)(
-              mroClass,
-              symbolTable,
-              /* includeInstanceVars */
-              false
-            );
-          }
-        }
         const staticmethod = (_a = decorators === null || decorators === void 0 ? void 0 : decorators.some((d) => this._checkDecorator(d, "staticmethod"))) !== null && _a !== void 0 ? _a : false;
         const classmethod = (_b = decorators === null || decorators === void 0 ? void 0 : decorators.some((d) => this._checkDecorator(d, "classmethod"))) !== null && _b !== void 0 ? _b : false;
-        const completionMap = new CompletionMap();
-        symbolTable.forEach((symbol, name) => {
-          var _a2;
-          let decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
-          if (decl && decl.type === 5) {
-            if (StringUtils.isPatternInSymbol(partialName.value, name)) {
-              const declaredType = (_a2 = this._evaluator.getTypeForDeclaration(decl)) === null || _a2 === void 0 ? void 0 : _a2.type;
-              if (!declaredType) {
-                return;
-              }
-              let isProperty = (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isPropertyClass(declaredType);
-              if (SymbolNameUtils.isDunderName(name)) {
-                isProperty = false;
-              }
-              if (!(0, types_1.isFunction)(declaredType) && !isProperty) {
-                return;
-              }
-              if (isProperty) {
-                const typedDecls = symbol.getTypedDeclarations();
-                if (typedDecls.length > 0 && typedDecls[0].type === 5) {
-                  decl = typedDecls[0];
-                }
-              }
-              const isDeclaredStaticMethod = (0, types_1.isFunction)(declaredType) && types_1.FunctionType.isStaticMethod(declaredType);
-              const isDeclaredClassMethod = (0, types_1.isFunction)(declaredType) && types_1.FunctionType.isClassMethod(declaredType) && name !== "__init_subclass__";
-              if (staticmethod !== isDeclaredStaticMethod || classmethod !== isDeclaredClassMethod) {
-                return;
-              }
-              const methodSignature = this._printMethodSignature(classResults.classType, decl);
-              let text;
-              if ((0, sourceMapper_1.isStubFile)(this._filePath)) {
-                text = `${methodSignature}: ...`;
-              } else {
-                const methodBody = this._printOverriddenMethodBody(classResults.classType, isDeclaredStaticMethod, isProperty, decl);
-                text = `${methodSignature}:
-${methodBody}`;
-              }
-              const textEdit = this._createReplaceEdits(priorWord, partialName, text);
-              this._addSymbol(name, symbol, partialName.value, completionMap, {
-                // method signature already contains ()
-                funcParensDisabled: true,
-                edits: {
-                  format: this._options.snippet ? vscode_languageserver_1.InsertTextFormat.Snippet : void 0,
-                  textEdit
-                }
-              });
+        const appendMember = (map, member, name) => {
+          if (!(0, types_1.isInstantiableClass)(member.classType) || member.classType.details === classResults.classType.details || !StringUtils.isPatternInSymbol(partialName.value, name)) {
+            return;
+          }
+          const symbol = member.symbol;
+          const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+          if (!decl || decl.type !== 5) {
+            return;
+          }
+          const declaredType = this._evaluator.getTypeOfMember(member);
+          if (!declaredType) {
+            return;
+          }
+          const isDeclaredStaticMethod = (0, types_1.isFunction)(declaredType) && types_1.FunctionType.isStaticMethod(declaredType);
+          const isDeclaredClassMethod = (0, types_1.isFunction)(declaredType) && types_1.FunctionType.isClassMethod(declaredType) && name !== "__init_subclass__";
+          if (staticmethod !== isDeclaredStaticMethod || classmethod !== isDeclaredClassMethod) {
+            return;
+          }
+          let isProperty = (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isPropertyClass(declaredType);
+          if (SymbolNameUtils.isDunderName(name)) {
+            isProperty = false;
+          }
+          let funcType = void 0;
+          if ((0, types_1.isFunction)(declaredType)) {
+            funcType = declaredType;
+          } else if (isProperty) {
+            const getter = (0, typeUtils_1.lookUpClassMember)(declaredType, "fget");
+            if (!getter) {
+              return;
             }
+            const member2 = this._evaluator.getTypeOfMember(getter);
+            if (!(0, types_1.isFunction)(member2)) {
+              return;
+            }
+            funcType = member2;
           }
-        });
+          if (!funcType || !funcType.details.declaration) {
+            return;
+          }
+          const methodSignature = this._printMethodSignature(classResults.classType, funcType);
+          let text;
+          if ((0, sourceMapper_1.isStubFile)(this._filePath)) {
+            text = `${methodSignature}: ...`;
+          } else {
+            const methodBody = this._printOverriddenMethodBody(classResults.classType, isDeclaredStaticMethod, isProperty, decl);
+            text = `${methodSignature}:
+${methodBody}`;
+          }
+          const textEdit = this._createReplaceEdits(priorWord, partialName, text);
+          this._addSymbol(name, symbol, partialName.value, map, {
+            // method signature already contains ()
+            funcParensDisabled: true,
+            edits: {
+              format: this._options.snippet ? vscode_languageserver_1.InsertTextFormat.Snippet : void 0,
+              textEdit
+            }
+          });
+        };
+        const completionMap = new CompletionMap();
+        const classMemberMap = (0, typeUtils_1.getClassFieldsRecursive)(classResults.classType);
+        classMemberMap.forEach((member, name) => appendMember(completionMap, member, name));
+        if (classResults.classType.details.effectiveMetaclass && !(0, types_1.isUnknown)(classResults.classType.details.effectiveMetaclass)) {
+          const metaClassMemberMap = (0, typeUtils_1.getClassFieldsRecursive)(classResults.classType.details.effectiveMetaclass);
+          metaClassMemberMap.forEach((member, name) => appendMember(completionMap, member, name));
+        }
         return { completionMap };
       }
       _createReplaceEdits(priorWord, node, text) {
@@ -36385,16 +36416,25 @@ ${methodBody}`;
         };
         return vscode_languageserver_1.TextEdit.replace(range, text);
       }
-      _printMethodSignature(classType, decl) {
-        const node = decl.node;
+      _printMethodSignature(classType, funcType) {
+        const decl = funcType.details.declaration;
         let ellipsisForDefault;
         if ((0, sourceMapper_1.isStubFile)(this._filePath)) {
           ellipsisForDefault = true;
         } else if (classType.details.moduleName === decl.moduleName) {
           ellipsisForDefault = false;
         }
-        const printFlags = (0, sourceMapper_1.isStubFile)(this._filePath) ? 1 | 2 : 2;
-        const paramList = node.parameters.map((param, index) => {
+        const printOptionsUsingSyntax = (0, sourceMapper_1.isStubFile)(this._filePath) ? 1 | 2 : 2;
+        const printOptionsUsingType = {
+          enforcePythonSyntax: true,
+          expandTypeAlias: false,
+          omitTypeArgumentsIfUnknown: true,
+          printUnknownWithAny: true
+        };
+        const getTypeToPrint = (mainType, fallbackType) => {
+          return mainType && (!(0, types_1.isUnknown)(mainType) || (fallbackType === null || fallbackType === void 0 ? void 0 : fallbackType.category) === 10) ? mainType : fallbackType;
+        };
+        const paramList = funcType.details.parameters.map((param, index) => {
           let paramString = "";
           if (param.category === 1) {
             paramString += "*";
@@ -36402,43 +36442,74 @@ ${methodBody}`;
             paramString += "**";
           }
           if (param.name) {
-            paramString += param.name.value;
+            paramString += param.name;
           }
-          const paramTypeAnnotation = ParseTreeUtils.getTypeAnnotationForParameter(node, index);
-          if (paramTypeAnnotation) {
-            paramString += ": " + ParseTreeUtils.printExpression(paramTypeAnnotation, printFlags);
+          if (param.typeAnnotation) {
+            const originalType = funcType.details.parameters[index].type;
+            const typeToPrint = getTypeToPrint(types_1.FunctionType.getEffectiveParameterType(funcType, index), originalType);
+            const strType = isTypeUsableForPrint(typeToPrint, originalType) ? this._evaluator.printType(typeToPrint, printOptionsUsingType) : ParseTreeUtils.printExpression(param.typeAnnotation, printOptionsUsingSyntax);
+            paramString += ": " + strType;
           }
-          if (param.defaultValue) {
-            paramString += paramTypeAnnotation ? " = " : "=";
-            const useEllipsis = ellipsisForDefault !== null && ellipsisForDefault !== void 0 ? ellipsisForDefault : !isSimpleDefault(param.defaultValue);
-            paramString += useEllipsis ? "..." : ParseTreeUtils.printExpression(param.defaultValue, printFlags);
+          if (param.defaultValueExpression) {
+            paramString += param.typeAnnotation ? " = " : "=";
+            const useEllipsis = ellipsisForDefault !== null && ellipsisForDefault !== void 0 ? ellipsisForDefault : !isSimpleDefault(param.defaultValueExpression);
+            paramString += useEllipsis ? "..." : ParseTreeUtils.printExpression(param.defaultValueExpression, printOptionsUsingSyntax);
           }
-          if (!paramString && !param.name && param.category === 0) {
+          if (!paramString && !param.name && param.category === 0 && index < funcType.details.parameters.length - 1) {
             return "/";
           }
           return paramString;
-        }).join(", ");
-        let methodSignature = node.name.value + "(" + paramList + ")";
-        if (node.returnTypeAnnotation) {
-          methodSignature += " -> " + ParseTreeUtils.printExpression(node.returnTypeAnnotation, printFlags);
-        } else if (node.functionAnnotationComment) {
-          methodSignature += " -> " + ParseTreeUtils.printExpression(node.functionAnnotationComment.returnTypeAnnotation, printFlags);
+        });
+        for (let i = paramList.length - 1; i >= 0; i--) {
+          if (paramList[i] !== "") {
+            break;
+          }
+          paramList.pop();
+        }
+        let methodSignature = funcType.details.name + "(" + paramList.join(", ") + ")";
+        const strReturnType = getReturnTypeStr(this._evaluator, funcType, printOptionsUsingSyntax);
+        if (strReturnType) {
+          methodSignature += " -> " + strReturnType;
         }
         return methodSignature;
-        function isSimpleDefault(node2) {
-          switch (node2.nodeType) {
+        function getReturnTypeStr(evaluator, funcType2, printFlags) {
+          const originalType = funcType2.details.declaredReturnType;
+          const typeToPrint = getTypeToPrint(types_1.FunctionType.getSpecializedReturnType(funcType2), originalType);
+          const node = funcType2.details.declaration.node;
+          if (!node.returnTypeAnnotation && !node.functionAnnotationComment) {
+            return void 0;
+          }
+          if (typeToPrint && isTypeUsableForPrint(typeToPrint, originalType)) {
+            return evaluator.printType(typeToPrint, printOptionsUsingType);
+          }
+          if (node.returnTypeAnnotation) {
+            return ParseTreeUtils.printExpression(node.returnTypeAnnotation, printFlags);
+          }
+          if (node.functionAnnotationComment) {
+            return ParseTreeUtils.printExpression(node.functionAnnotationComment.returnTypeAnnotation, printFlags);
+          }
+          return void 0;
+        }
+        function isTypeUsableForPrint(effectiveType, originalType) {
+          if (!effectiveType) {
+            return false;
+          }
+          return !(0, types_1.isUnknown)(effectiveType) || (originalType === null || originalType === void 0 ? void 0 : originalType.category) === 10;
+        }
+        function isSimpleDefault(node) {
+          switch (node.nodeType) {
             case 40:
             case 11:
             case 35:
               return true;
             case 49:
-              return (node2.token.flags & 64) === 0;
+              return (node.token.flags & 64) === 0;
             case 48:
-              return node2.strings.every(isSimpleDefault);
+              return node.strings.every(isSimpleDefault);
             case 55:
-              return isSimpleDefault(node2.expression);
+              return isSimpleDefault(node.expression);
             case 7:
-              return isSimpleDefault(node2.leftExpression) && isSimpleDefault(node2.rightExpression);
+              return isSimpleDefault(node.leftExpression) && isSimpleDefault(node.rightExpression);
             default:
               return false;
           }
@@ -37284,7 +37355,7 @@ ${methodBody}`;
       _addSymbolsForSymbolTable(symbolTable, includeSymbolCallback, priorWord, node, isInImport, boundObjectOrClass, completionMap) {
         const insideTypeAnnotation = ParseTreeUtils.isWithinAnnotationComment(node) || ParseTreeUtils.isWithinTypeAnnotation(
           node,
-          /*requireQuotedAnnotation*/
+          /* requireQuotedAnnotation */
           false
         );
         symbolTable.forEach((symbol, name) => {
@@ -38512,10 +38583,25 @@ var require_hoverProvider = __commonJS({
                 }
               }
             }
-            const typeText = typeVarName || node.value + this._getTypeText(typeNode, evaluator, expandTypeAlias);
+            let typeText;
+            const varType = this._getType(evaluator, typeNode);
+            if (varType.category === 5 || varType.category === 6) {
+              typeText = (0, tooltipUtils_1.getToolTipForType)(
+                type,
+                label,
+                node.value,
+                evaluator,
+                /* isProperty */
+                false,
+                functionSignatureDisplay
+              );
+            } else {
+              typeText = typeVarName || node.value + this._getTypeText(typeNode, evaluator, expandTypeAlias);
+              typeText = `(${label}) ` + typeText;
+            }
             this._addResultsPart(
               parts,
-              `(${label}) ${typeText}`,
+              typeText,
               /* python */
               true
             );
@@ -50412,6 +50498,7 @@ var require_patternMatching = __commonJS({
     }
     exports.checkForUnusedPattern = checkForUnusedPattern;
     function narrowTypeBasedOnSequencePattern(evaluator, type, pattern, isPositiveTest) {
+      type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
       let sequenceInfo = getSequencePatternInfo(evaluator, type, pattern.entries.length, pattern.starEntryIndex);
       sequenceInfo = sequenceInfo.filter((entry) => {
         if (entry.definiteNoMatch) {
@@ -52602,6 +52689,9 @@ var require_codeFlowEngine = __commonJS({
         if (noReturnAnalysisDepth > types_1.maxTypeRecursionCount) {
           return false;
         }
+        if (node.leftExpression.nodeType === 30) {
+          return false;
+        }
         callIsNoReturnCache.set(node.id, false);
         noReturnAnalysisDepth++;
         try {
@@ -52882,15 +52972,77 @@ var require_constructorTransform = __commonJS({
       const origFunctionTypeResult = evaluator.getTypeOfArgument(argList[0]);
       const origFunctionType = origFunctionTypeResult.type;
       evaluator.inferReturnTypeIfNecessary(origFunctionType);
-      if (!(0, types_1.isFunction)(origFunctionType)) {
-        return result;
-      }
       if (argList.some(
         (arg) => arg.argumentCategory !== 0
         /* Simple */
       )) {
         return result;
       }
+      if ((0, types_1.isFunction)(origFunctionType)) {
+        const transformResult = applyPartialTransformToFunction(evaluator, errorNode, argList, callMemberType, origFunctionType);
+        if (!transformResult) {
+          return result;
+        }
+        const newPartialClass = types_1.ClassType.cloneForSymbolTableUpdate(result.returnType);
+        newPartialClass.details.fields.set("__call__", symbol_1.Symbol.createWithType(4, transformResult.returnType));
+        return {
+          returnType: newPartialClass,
+          isTypeIncomplete: result.isTypeIncomplete,
+          argumentErrors: transformResult.argumentErrors
+        };
+      }
+      if ((0, types_1.isOverloadedFunction)(origFunctionType)) {
+        const applicableOverloads = [];
+        let sawArgErrors = false;
+        types_1.OverloadedFunctionType.getOverloads(origFunctionType).forEach((overload) => {
+          const transformResult = applyPartialTransformToFunction(
+            evaluator,
+            /* errorNode */
+            void 0,
+            argList,
+            callMemberType,
+            overload
+          );
+          if (transformResult) {
+            if (transformResult.argumentErrors) {
+              sawArgErrors = true;
+            } else if ((0, types_1.isFunction)(transformResult.returnType)) {
+              applicableOverloads.push(transformResult.returnType);
+            }
+          }
+        });
+        if (applicableOverloads.length === 0) {
+          if (sawArgErrors) {
+            evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noOverload().format({
+              name: origFunctionType.overloads[0].details.name
+            }), errorNode);
+          }
+          return result;
+        }
+        const newPartialClass = types_1.ClassType.cloneForSymbolTableUpdate(result.returnType);
+        let synthesizedCallType;
+        if (applicableOverloads.length === 1) {
+          synthesizedCallType = applicableOverloads[0];
+        } else {
+          synthesizedCallType = types_1.OverloadedFunctionType.create(
+            // Set the "overloaded" flag for each of the __call__ overloads.
+            applicableOverloads.map((overload) => types_1.FunctionType.cloneWithNewFlags(
+              overload,
+              overload.details.flags | 256
+              /* Overloaded */
+            ))
+          );
+        }
+        newPartialClass.details.fields.set("__call__", symbol_1.Symbol.createWithType(4, synthesizedCallType));
+        return {
+          returnType: newPartialClass,
+          isTypeIncomplete: result.isTypeIncomplete,
+          argumentErrors: false
+        };
+      }
+      return result;
+    }
+    function applyPartialTransformToFunction(evaluator, errorNode, argList, partialCallMemberType, origFunctionType) {
       const paramMap = /* @__PURE__ */ new Map();
       const paramListDetails = (0, parameterUtils_1.getParameterListDetails)(origFunctionType);
       let argumentErrors = false;
@@ -52914,19 +53066,23 @@ var require_constructorTransform = __commonJS({
                 (0, typeUtils_1.makeInferenceContext)(paramType)
               );
               if (!evaluator.assignType(paramType, argTypeResult.type, diag, typeVarContext)) {
-                evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argAssignmentParamFunction().format({
-                  argType: evaluator.printType(argTypeResult.type),
-                  paramType: evaluator.printType(paramType),
-                  functionName: origFunctionType.details.name,
-                  paramName: (_a = paramListDetails.params[paramListDetails.argsIndex].param.name) !== null && _a !== void 0 ? _a : ""
-                }), (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : errorNode);
+                if (errorNode) {
+                  evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argAssignmentParamFunction().format({
+                    argType: evaluator.printType(argTypeResult.type),
+                    paramType: evaluator.printType(paramType),
+                    functionName: origFunctionType.details.name,
+                    paramName: (_a = paramListDetails.params[paramListDetails.argsIndex].param.name) !== null && _a !== void 0 ? _a : ""
+                  }), (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : errorNode);
+                }
                 argumentErrors = true;
               }
             } else {
               if (!reportedPositionalError) {
-                evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, paramListDetails.positionParamCount === 1 ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne() : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
-                  expected: paramListDetails.positionParamCount
-                }), (_c = arg.valueExpression) !== null && _c !== void 0 ? _c : errorNode);
+                if (errorNode) {
+                  evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, paramListDetails.positionParamCount === 1 ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne() : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
+                    expected: paramListDetails.positionParamCount
+                  }), (_c = arg.valueExpression) !== null && _c !== void 0 ? _c : errorNode);
+                }
               }
               reportedPositionalError = true;
               argumentErrors = true;
@@ -52942,12 +53098,14 @@ var require_constructorTransform = __commonJS({
               (0, typeUtils_1.makeInferenceContext)(paramType)
             );
             if (!evaluator.assignType(paramType, argTypeResult.type, diag, typeVarContext)) {
-              evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argAssignmentParamFunction().format({
-                argType: evaluator.printType(argTypeResult.type),
-                paramType: evaluator.printType(paramType),
-                functionName: origFunctionType.details.name,
-                paramName
-              }), (_e = arg.valueExpression) !== null && _e !== void 0 ? _e : errorNode);
+              if (errorNode) {
+                evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argAssignmentParamFunction().format({
+                  argType: evaluator.printType(argTypeResult.type),
+                  paramType: evaluator.printType(paramType),
+                  functionName: origFunctionType.details.name,
+                  paramName
+                }), (_e = arg.valueExpression) !== null && _e !== void 0 ? _e : errorNode);
+              }
               argumentErrors = true;
             }
             paramMap.set(paramName, false);
@@ -52959,7 +53117,9 @@ var require_constructorTransform = __commonJS({
           });
           if (!matchingParam) {
             if (paramListDetails.kwargsIndex === void 0) {
-              evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: arg.name.value }), arg.name);
+              if (errorNode) {
+                evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramNameMissing().format({ name: arg.name.value }), arg.name);
+              }
               argumentErrors = true;
             } else {
               const paramType = types_1.FunctionType.getEffectiveParameterType(origFunctionType, paramListDetails.params[paramListDetails.kwargsIndex].index);
@@ -52971,12 +53131,14 @@ var require_constructorTransform = __commonJS({
                 (0, typeUtils_1.makeInferenceContext)(paramType)
               );
               if (!evaluator.assignType(paramType, argTypeResult.type, diag, typeVarContext)) {
-                evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argAssignmentParamFunction().format({
-                  argType: evaluator.printType(argTypeResult.type),
-                  paramType: evaluator.printType(paramType),
-                  functionName: origFunctionType.details.name,
-                  paramName: (_f = paramListDetails.params[paramListDetails.kwargsIndex].param.name) !== null && _f !== void 0 ? _f : ""
-                }), (_g = arg.valueExpression) !== null && _g !== void 0 ? _g : errorNode);
+                if (errorNode) {
+                  evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argAssignmentParamFunction().format({
+                    argType: evaluator.printType(argTypeResult.type),
+                    paramType: evaluator.printType(paramType),
+                    functionName: origFunctionType.details.name,
+                    paramName: (_f = paramListDetails.params[paramListDetails.kwargsIndex].param.name) !== null && _f !== void 0 ? _f : ""
+                  }), (_g = arg.valueExpression) !== null && _g !== void 0 ? _g : errorNode);
+                }
                 argumentErrors = true;
               }
             }
@@ -52984,7 +53146,9 @@ var require_constructorTransform = __commonJS({
             const paramName = matchingParam.param.name;
             const paramType = types_1.FunctionType.getEffectiveParameterType(origFunctionType, matchingParam.index);
             if (paramMap.has(paramName)) {
-              evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramAlreadyAssigned().format({ name: arg.name.value }), arg.name);
+              if (errorNode) {
+                evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramAlreadyAssigned().format({ name: arg.name.value }), arg.name);
+              }
               argumentErrors = true;
             } else {
               const diag = new diagnostic_1.DiagnosticAddendum();
@@ -52995,12 +53159,14 @@ var require_constructorTransform = __commonJS({
                 (0, typeUtils_1.makeInferenceContext)(paramType)
               );
               if (!evaluator.assignType(paramType, argTypeResult.type, diag, typeVarContext)) {
-                evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argAssignmentParamFunction().format({
-                  argType: evaluator.printType(argTypeResult.type),
-                  paramType: evaluator.printType(paramType),
-                  functionName: origFunctionType.details.name,
-                  paramName
-                }), (_h = arg.valueExpression) !== null && _h !== void 0 ? _h : errorNode);
+                if (errorNode) {
+                  evaluator.addDiagnostic((0, analyzerNodeInfo_1.getFileInfo)(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.argAssignmentParamFunction().format({
+                    argType: evaluator.printType(argTypeResult.type),
+                    paramType: evaluator.printType(paramType),
+                    functionName: origFunctionType.details.name,
+                    paramName
+                  }), (_h = arg.valueExpression) !== null && _h !== void 0 ? _h : errorNode);
+                }
                 argumentErrors = true;
               }
               paramMap.set(paramName, true);
@@ -53010,7 +53176,7 @@ var require_constructorTransform = __commonJS({
       });
       const specializedFunctionType = (0, typeUtils_1.applySolvedTypeVars)(origFunctionType, typeVarContext);
       if (!(0, types_1.isFunction)(specializedFunctionType)) {
-        return result;
+        return void 0;
       }
       const updatedParamList = specializedFunctionType.details.parameters.map((param, index) => {
         const specializedParam = { ...param };
@@ -53036,23 +53202,17 @@ var require_constructorTransform = __commonJS({
         return param.category === 2;
       });
       const newParamList = [...unassignedParamList, ...assignedKeywordParamList, ...kwargsParam];
-      const newCallMemberType = types_1.FunctionType.createInstance(callMemberType.details.name, callMemberType.details.fullName, callMemberType.details.moduleName, callMemberType.details.flags, specializedFunctionType.details.docString);
-      if (callMemberType.details.parameters.length > 0) {
-        types_1.FunctionType.addParameter(newCallMemberType, callMemberType.details.parameters[0]);
+      const newCallMemberType = types_1.FunctionType.createInstance(partialCallMemberType.details.name, partialCallMemberType.details.fullName, partialCallMemberType.details.moduleName, partialCallMemberType.details.flags, specializedFunctionType.details.docString);
+      if (partialCallMemberType.details.parameters.length > 0) {
+        types_1.FunctionType.addParameter(newCallMemberType, partialCallMemberType.details.parameters[0]);
       }
       newParamList.forEach((param) => {
         types_1.FunctionType.addParameter(newCallMemberType, param);
       });
       newCallMemberType.details.declaredReturnType = specializedFunctionType.details.declaredReturnType ? types_1.FunctionType.getSpecializedReturnType(specializedFunctionType) : specializedFunctionType.inferredReturnType;
-      newCallMemberType.details.declaration = callMemberType.details.declaration;
+      newCallMemberType.details.declaration = partialCallMemberType.details.declaration;
       newCallMemberType.details.typeVarScopeId = specializedFunctionType.details.typeVarScopeId;
-      const newPartialClass = types_1.ClassType.cloneForSymbolTableUpdate(result.returnType);
-      newPartialClass.details.fields.set("__call__", symbol_1.Symbol.createWithType(4, newCallMemberType));
-      return {
-        returnType: newPartialClass,
-        isTypeIncomplete: false,
-        argumentErrors
-      };
+      return { returnType: newCallMemberType, isTypeIncomplete: false, argumentErrors };
     }
   }
 });
@@ -54145,9 +54305,6 @@ var require_enums = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.getEnumAutoValueType = exports.getTypeOfEnumMember = exports.isDeclInEnumClass = exports.transformTypeForPossibleEnumClass = exports.createEnumType = exports.isKnownEnumType = void 0;
-    var debug_1 = require_debug2();
-    var positionUtils_1 = require_positionUtils();
-    var textRange_1 = require_textRange();
     var analyzerNodeInfo_1 = require_analyzerNodeInfo();
     var parseTreeUtils_1 = require_parseTreeUtils();
     var symbol_1 = require_symbol();
@@ -54159,19 +54316,16 @@ var require_enums = __commonJS({
       return knownEnumTypes.some((c) => c === className);
     }
     exports.isKnownEnumType = isKnownEnumType;
-    function createEnumType(errorNode, enumClass, argList) {
+    function createEnumType(evaluator, errorNode, enumClass, argList) {
       const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
-      let className = "enum";
       if (argList.length === 0) {
         return void 0;
-      } else {
-        const nameArg = argList[0];
-        if (nameArg.argumentCategory === 0 && nameArg.valueExpression && nameArg.valueExpression.nodeType === 48) {
-          className = nameArg.valueExpression.strings.map((s) => s.value).join("");
-        } else {
-          return void 0;
-        }
       }
+      const nameArg = argList[0];
+      if (nameArg.argumentCategory !== 0 || !nameArg.valueExpression || nameArg.valueExpression.nodeType !== 48 || nameArg.valueExpression.strings.length !== 1 || nameArg.valueExpression.strings[0].nodeType !== 49) {
+        return void 0;
+      }
+      const className = nameArg.valueExpression.strings.map((s) => s.value).join("");
       const classType = types_1.ClassType.createInstantiable(
         className,
         (0, parseTreeUtils_1.getClassFullName)(errorNode, fileInfo.moduleName, className),
@@ -54189,36 +54343,93 @@ var require_enums = __commonJS({
       classFields.set("__class__", symbol_1.Symbol.createWithType(4 | 64, classType));
       if (argList.length < 2) {
         return void 0;
-      } else {
-        const entriesArg = argList[1];
-        if (entriesArg.argumentCategory !== 0 || !entriesArg.valueExpression || entriesArg.valueExpression.nodeType !== 48) {
+      }
+      const initArg = argList[1];
+      if (initArg.argumentCategory !== 0 || !initArg.valueExpression) {
+        return void 0;
+      }
+      const intClassType = evaluator.getBuiltInType(errorNode, "int");
+      if (!intClassType || !(0, types_1.isInstantiableClass)(intClassType)) {
+        return void 0;
+      }
+      const classInstanceType = types_1.ClassType.cloneAsInstance(classType);
+      if (initArg.valueExpression.nodeType === 48) {
+        if (!initArg.valueExpression.strings.every(
+          (str) => str.nodeType === 49
+          /* String */
+        )) {
           return void 0;
-        } else {
-          const entries = entriesArg.valueExpression.strings.map((s) => s.value).join("").split(" ");
-          entries.forEach((entryName) => {
-            entryName = entryName.trim();
-            if (entryName) {
-              const entryType = types_1.UnknownType.create();
-              const newSymbol = symbol_1.Symbol.createWithType(4, entryType);
-              const stringNode = entriesArg.valueExpression;
-              (0, debug_1.assert)(
-                stringNode.nodeType === 48
-                /* StringList */
-              );
-              const fileInfo2 = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
-              const declaration = {
-                type: 1,
-                node: stringNode,
-                isRuntimeTypeExpression: true,
-                path: fileInfo2.filePath,
-                range: (0, positionUtils_1.convertOffsetsToRange)(stringNode.start, textRange_1.TextRange.getEnd(stringNode), fileInfo2.lines),
-                moduleName: fileInfo2.moduleName,
-                isInExceptSuite: false
-              };
-              newSymbol.addDeclaration(declaration);
-              classFields.set(entryName, newSymbol);
+        }
+        const initStr = initArg.valueExpression.strings.map((s) => s.value).join("").trim();
+        const entryNames = initStr.split(/[\s,]+/);
+        for (const [index, entryName] of entryNames.entries()) {
+          if (!entryName) {
+            return void 0;
+          }
+          const valueType = types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(intClassType), index + 1);
+          const enumLiteral = new types_1.EnumLiteral(classType.details.fullName, classType.details.name, entryName, valueType);
+          const newSymbol = symbol_1.Symbol.createWithType(4, types_1.ClassType.cloneWithLiteral(classInstanceType, enumLiteral));
+          classFields.set(entryName, newSymbol);
+        }
+        return classType;
+      }
+      if (initArg.valueExpression.nodeType === 31 || initArg.valueExpression.nodeType === 52) {
+        const entries = initArg.valueExpression.nodeType === 31 ? initArg.valueExpression.entries : initArg.valueExpression.expressions;
+        if (entries.length === 0) {
+          return void 0;
+        }
+        let isSimpleString = false;
+        for (const [index, entry] of entries.entries()) {
+          if (index === 0) {
+            isSimpleString = entry.nodeType === 48;
+          }
+          let nameNode;
+          let valueType;
+          if (entry.nodeType === 48) {
+            if (!isSimpleString) {
+              return void 0;
             }
-          });
+            nameNode = entry;
+            valueType = types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(intClassType), index + 1);
+          } else if (entry.nodeType === 52) {
+            if (isSimpleString) {
+              return void 0;
+            }
+            if (entry.expressions.length !== 2) {
+              return void 0;
+            }
+            nameNode = entry.expressions[0];
+            valueType = evaluator.getTypeOfExpression(entry.expressions[1]).type;
+          } else {
+            return void 0;
+          }
+          if (nameNode.nodeType !== 48 || nameNode.strings.length !== 1 || nameNode.strings[0].nodeType !== 49) {
+            return void 0;
+          }
+          const entryName = nameNode.strings[0].value;
+          const enumLiteral = new types_1.EnumLiteral(classType.details.fullName, classType.details.name, entryName, valueType);
+          const newSymbol = symbol_1.Symbol.createWithType(4, types_1.ClassType.cloneWithLiteral(classInstanceType, enumLiteral));
+          classFields.set(entryName, newSymbol);
+        }
+      }
+      if (initArg.valueExpression.nodeType === 15) {
+        const entries = initArg.valueExpression.entries;
+        if (entries.length === 0) {
+          return void 0;
+        }
+        for (const entry of entries) {
+          if (entry.nodeType !== 17) {
+            return void 0;
+          }
+          const nameNode = entry.keyExpression;
+          const valueType = evaluator.getTypeOfExpression(entry.valueExpression).type;
+          if (nameNode.nodeType !== 48 || nameNode.strings.length !== 1 || nameNode.strings[0].nodeType !== 49) {
+            return void 0;
+          }
+          const entryName = nameNode.strings[0].value;
+          const enumLiteral = new types_1.EnumLiteral(classType.details.fullName, classType.details.name, entryName, valueType);
+          const newSymbol = symbol_1.Symbol.createWithType(4, types_1.ClassType.cloneWithLiteral(classInstanceType, enumLiteral));
+          classFields.set(entryName, newSymbol);
         }
       }
       return classType;
@@ -60429,11 +60640,16 @@ var require_typeEvaluator = __commonJS({
       }
       function getTypeOfCall(node, inferenceContext, flags) {
         var _a;
-        const baseTypeResult = getTypeOfExpression(
-          node.leftExpression,
-          2
-          /* DoNotSpecialize */
-        );
+        let baseTypeResult;
+        if (node.leftExpression.nodeType === 30) {
+          baseTypeResult = getTypeOfLambdaForCall(node, inferenceContext);
+        } else {
+          baseTypeResult = getTypeOfExpression(
+            node.leftExpression,
+            2
+            /* DoNotSpecialize */
+          );
+        }
         const argList = node.arguments.map((arg) => {
           const functionArg = {
             valueExpression: arg.valueExpression,
@@ -60502,6 +60718,50 @@ var require_typeEvaluator = __commonJS({
         }
         return typeResult;
       }
+      function getTypeOfLambdaForCall(node, inferenceContext) {
+        (0, debug_1.assert)(
+          node.leftExpression.nodeType === 30
+          /* Lambda */
+        );
+        const expectedType = types_1.FunctionType.createSynthesizedInstance("");
+        expectedType.details.declaredReturnType = inferenceContext ? inferenceContext.expectedType : types_1.UnknownType.create();
+        let isArgTypeIncomplete = false;
+        node.arguments.forEach((arg, index) => {
+          const argTypeResult = getTypeOfExpression(arg.valueExpression);
+          if (argTypeResult.isIncomplete) {
+            isArgTypeIncomplete = true;
+          }
+          types_1.FunctionType.addParameter(expectedType, {
+            category: 0,
+            name: `p${index.toString()}`,
+            type: argTypeResult.type,
+            hasDeclaredType: true
+          });
+        });
+        const lambdaParams = node.leftExpression.parameters;
+        if (lambdaParams.length > 0) {
+          const lastParam = lambdaParams[lambdaParams.length - 1];
+          if (lastParam.category === 0 && !lastParam.name) {
+            types_1.FunctionType.addParameter(expectedType, {
+              category: 0,
+              name: "",
+              type: types_1.UnknownType.create()
+            });
+          }
+        }
+        function getLambdaType() {
+          return getTypeOfExpression(node.leftExpression, 2, (0, typeUtils_1.makeInferenceContext)(expectedType));
+        }
+        let typeResult = isArgTypeIncomplete || speculativeTypeTracker.isSpeculative(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? useSpeculativeMode(node.leftExpression, getLambdaType) : getLambdaType();
+        if (typeResult.typeErrors) {
+          typeResult = getTypeOfExpression(
+            node.leftExpression,
+            2
+            /* DoNotSpecialize */
+          );
+        }
+        return typeResult;
+      }
       function getTypeOfAssertType(node, inferenceContext) {
         if (node.arguments.length !== 2 || node.arguments[0].argumentCategory !== 0 || node.arguments[0].name !== void 0 || node.arguments[0].argumentCategory !== 0 || node.arguments[1].name !== void 0) {
           addError(localize_1.Localizer.Diagnostic.assertTypeArgs(), node);
@@ -60753,6 +61013,7 @@ var require_typeEvaluator = __commonJS({
           const argTypeOverride = expandedArgTypes[expandedTypesIndex];
           const hasArgTypeOverride = argTypeOverride.some((a) => a !== void 0);
           let possibleMatchResults = [];
+          let possibleMatchInvolvesIncompleteUnknown = false;
           isDefinitiveMatchFound = false;
           for (let overloadIndex = 0; overloadIndex < argParamMatches.length; overloadIndex++) {
             const overload = argParamMatches[overloadIndex].overload;
@@ -60799,8 +61060,11 @@ var require_typeEvaluator = __commonJS({
                 argResults: (_b = callResult.argResults) !== null && _b !== void 0 ? _b : []
               };
               matchedOverloads.push(matchedOverloadInfo);
-              if (callResult.isArgumentAnyOrUnknown) {
+              if (callResult.anyOrUnknownArgument) {
                 possibleMatchResults.push(matchedOverloadInfo);
+                if ((0, typeUtils_1.isIncompleteUnknown)(callResult.anyOrUnknownArgument)) {
+                  possibleMatchInvolvesIncompleteUnknown = true;
+                }
               } else {
                 returnTypes.push(callResult.returnType);
                 isDefinitiveMatchFound = true;
@@ -60832,7 +61096,7 @@ var require_typeEvaluator = __commonJS({
               });
               dedupedMatchResults = dedupedMatchResults.filter((t) => !(0, types_1.isNever)(t));
               const combinedTypes = (0, types_1.combineTypes)(dedupedMatchResults);
-              returnTypes.push(dedupedMatchResults.length > 1 ? types_1.UnknownType.createPossibleType(combinedTypes) : combinedTypes);
+              returnTypes.push(dedupedMatchResults.length > 1 ? types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown) : combinedTypes);
             }
           }
           if (!matchedOverload) {
@@ -60851,7 +61115,7 @@ var require_typeEvaluator = __commonJS({
         }
         return {
           argumentErrors: finalCallResult.argumentErrors,
-          isArgumentAnyOrUnknown: finalCallResult.isArgumentAnyOrUnknown,
+          anyOrUnknownArgument: finalCallResult.anyOrUnknownArgument,
           returnType: (0, types_1.combineTypes)(returnTypes),
           isTypeIncomplete,
           specializedInitSelfType: finalCallResult.specializedInitSelfType,
@@ -61486,7 +61750,7 @@ var require_typeEvaluator = __commonJS({
                       return types_1.AnyType.create();
                     }
                     if ((0, types_1.isClass)(unexpandedSubtype) && (0, enums_1.isKnownEnumType)(className)) {
-                      return (_d = (0, enums_1.createEnumType)(errorNode, expandedSubtype, argList)) !== null && _d !== void 0 ? _d : types_1.UnknownType.create();
+                      return (_d = (0, enums_1.createEnumType)(evaluatorInterface, errorNode, expandedSubtype, argList)) !== null && _d !== void 0 ? _d : types_1.UnknownType.create();
                     }
                     if (className === "TypedDict") {
                       return (0, typedDicts_1.createTypedDictType)(evaluatorInterface, errorNode, expandedSubtype, argList);
@@ -62344,7 +62608,7 @@ var require_typeEvaluator = __commonJS({
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
         let specializedInitSelfType;
-        let isArgumentAnyOrUnknown = false;
+        let anyOrUnknownArgument;
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
         if (type.boundTypeVarScopeId) {
           if (type.preBoundFlags !== void 0 && type.boundToType && (0, typeUtils_1.requiresSpecialization)(type.boundToType)) {
@@ -62386,7 +62650,7 @@ var require_typeEvaluator = __commonJS({
                   skipUnknownArgCheck,
                   /* skipOverloadArg */
                   i === 0,
-                  /* useNarrowBoundOnly */
+                  /* isFirstPass */
                   passCount > 1 && i === 0,
                   typeCondition
                 );
@@ -62416,7 +62680,7 @@ var require_typeEvaluator = __commonJS({
             skipUnknownArgCheck,
             /* skipOverloadArg */
             false,
-            /* useNarrowBoundOnly */
+            /* isFirstPass */
             false,
             typeCondition
           );
@@ -62431,7 +62695,7 @@ var require_typeEvaluator = __commonJS({
             condition = (_a = types_1.TypeCondition.combine(condition, argResult.condition)) !== null && _a !== void 0 ? _a : [];
           }
           if ((0, types_1.isAnyOrUnknown)(argResult.argType)) {
-            isArgumentAnyOrUnknown = true;
+            anyOrUnknownArgument = anyOrUnknownArgument ? (0, typeUtils_1.preserveUnknown)(argResult.argType, anyOrUnknownArgument) : argResult.argType;
           }
           if (type.details.paramSpec) {
             if (argParam.argument.argumentCategory === 1) {
@@ -62520,7 +62784,7 @@ var require_typeEvaluator = __commonJS({
         return {
           argumentErrors,
           argResults,
-          isArgumentAnyOrUnknown,
+          anyOrUnknownArgument,
           returnType: specializedReturnType,
           isTypeIncomplete,
           activeParam: matchResults.activeParam,
@@ -62528,14 +62792,11 @@ var require_typeEvaluator = __commonJS({
           overloadsUsedForCall: argumentErrors ? [] : [type]
         };
       }
-      function adjustCallableReturnType(type) {
-        if ((0, types_1.isFunction)(type) && !type.details.name) {
-          type.details = {
-            ...type.details,
-            typeVarScopeId: types_1.WildcardTypeVarScopeId
-          };
+      function adjustCallableReturnType(returnType) {
+        if ((0, types_1.isFunction)(returnType) && !returnType.details.name) {
+          return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, types_1.WildcardTypeVarScopeId);
         }
-        return type;
+        return returnType;
       }
       function validateFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
         const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, typeResult, 0);
@@ -62653,7 +62914,7 @@ var require_typeEvaluator = __commonJS({
                 false,
                 /* skipOverloadArg */
                 false,
-                /* useNarrowBoundOnly */
+                /* isFirstPass */
                 false,
                 conditionFilter
               );
@@ -62682,7 +62943,7 @@ var require_typeEvaluator = __commonJS({
         }
         return !reportedArgError;
       }
-      function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
+      function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, skipUnknownCheck, skipOverloadArg, isFirstPass, conditionFilter) {
         var _a;
         let argType;
         let expectedTypeDiag;
@@ -62691,8 +62952,10 @@ var require_typeEvaluator = __commonJS({
         const functionName = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.name;
         if (argParam.argument.valueExpression) {
           let expectedType;
-          if (!(0, types_1.isTypeVar)(argParam.paramType) || argParam.paramType.scopeId !== (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId)) {
-            expectedType = (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, { useNarrowBoundOnly });
+          if (!isFirstPass || !(0, types_1.isTypeVar)(argParam.paramType) || argParam.paramType.scopeId !== (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId)) {
+            expectedType = (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, {
+              useNarrowBoundOnly: isFirstPass
+            });
           }
           if (expectedType && (0, types_1.isUnknown)(expectedType)) {
             expectedType = void 0;
@@ -64664,11 +64927,8 @@ var require_typeEvaluator = __commonJS({
             }
             return void 0;
           });
-          const minLambdaParamCount = node.parameters.filter((param) => param.category === 0 && param.defaultValue === void 0).length;
-          const maxLambdaParamCount = node.parameters.filter(
-            (param) => param.category === 0
-            /* Simple */
-          ).length;
+          const minLambdaParamCount = node.parameters.filter((param) => param.category === 0 && !!param.name && param.defaultValue === void 0).length;
+          const maxLambdaParamCount = node.parameters.filter((param) => param.category === 0 && !!param.name).length;
           expectedFunctionTypes = expectedFunctionTypes.filter((functionType2) => {
             const functionParamCount = functionType2.details.parameters.filter((param) => !!param.name && !param.hasDefault).length;
             const hasVarArgs = functionType2.details.parameters.some(
@@ -68306,6 +68566,10 @@ var require_typeEvaluator = __commonJS({
                 nodeToEvaluate = parent2;
                 continue;
               }
+              if (parent2.nodeType === 9 && nodeToEvaluate.nodeType === 30) {
+                nodeToEvaluate = parent2;
+                continue;
+              }
               flags = 2;
               break;
             }
@@ -72709,6 +72973,12 @@ var require_typeEvaluator = __commonJS({
         if (options === null || options === void 0 ? void 0 : options.useTypingUnpack) {
           flags |= 512;
         }
+        if (options === null || options === void 0 ? void 0 : options.printUnknownWithAny) {
+          flags |= 1;
+        }
+        if (options === null || options === void 0 ? void 0 : options.omitTypeArgumentsIfUnknown) {
+          flags |= 2;
+        }
         return TypePrinter.printType(type, flags, getFunctionEffectiveReturnType);
       }
       function parseStringAsTypeAnnotation(node) {
@@ -100978,12 +101248,12 @@ var PythonCodeActionProvider = class {
       }
     }
     if (diag.fix) {
-      const title = `Fix: ${diag.message.split(":")[0]}`;
       const action = {
-        title,
+        // @ts-ignore
+        title: diag.fix.title,
         kind: import_coc3.CodeActionKind.QuickFix,
         // @ts-ignore
-        edit: diag.fix
+        edit: diag.fix.edit
       };
       return [action];
     }
@@ -102441,7 +102711,8 @@ var MyPy = class extends BaseLinter {
     super(info, outputChannel, COLUMN_OFF_SET2);
   }
   async runLinter(document, cancellation) {
-    const messages = await this.run([import_coc17.Uri.parse(document.uri).fsPath], document, cancellation, REGEX2);
+    const args = ["--python-executable", this.pythonSettings.pythonPath, import_coc17.Uri.parse(document.uri).fsPath];
+    const messages = await this.run(args, document, cancellation, REGEX2);
     messages.forEach((msg) => {
       msg.severity = this.parseMessagesSeverity(msg.type, this.pythonSettings.linting.mypyCategorySeverity);
       msg.code = msg.type;
@@ -102741,12 +103012,31 @@ var Ruff = class extends BaseLinter {
     if (!fix)
       return null;
     const u = import_coc25.Uri.parse(filename).toString();
-    const range = import_coc25.Range.create(fix.location.row - 1, fix.location.column, fix.end_location.row - 1, fix.end_location.column);
-    return {
-      changes: {
-        [u]: [import_coc25.TextEdit.replace(range, fix.content)]
-      }
-    };
+    if (fix.edits && fix.edits.length) {
+      const changes = fix.edits.map((edit) => {
+        const range = import_coc25.Range.create(edit.location.row - 1, edit.location.column, edit.end_location.row - 1, edit.end_location.column);
+        return import_coc25.TextEdit.replace(range, edit.content);
+      });
+      return {
+        title: `Ruff: ${fix.message}`,
+        edit: {
+          changes: {
+            [u]: changes
+          }
+        }
+      };
+    } else if (fix.location && fix.end_location) {
+      const range = import_coc25.Range.create(fix.location.row - 1, fix.location.column, fix.end_location.row - 1, fix.end_location.column);
+      return {
+        title: `Ruff: ${fix.message}`,
+        edit: {
+          changes: {
+            [u]: [import_coc25.TextEdit.replace(range, fix.content || "")]
+          }
+        }
+      };
+    }
+    return null;
   }
   async parseMessages(output) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coc-pyright",
-  "version": "1.1.303",
+  "version": "1.1.304",
   "description": "Pyright extension for coc.nvim, static type checker for Python",
   "author": "Heyward Fann <fannheyward@gmail.com>",
   "license": "MIT",
@@ -44,7 +44,7 @@
     "@types/which": "^2.0.0",
     "@typescript-eslint/eslint-plugin": "^5.6.0",
     "@typescript-eslint/parser": "^5.6.0",
-    "@zzzen/pyright-internal": "^1.2.0-dev.20230409",
+    "@zzzen/pyright-internal": "^1.2.0-dev.20230416",
     "coc.nvim": "^0.0.82",
     "diff-match-patch": "^1.0.5",
     "esbuild": "^0.17.10",
@@ -1572,6 +1572,6 @@
     ]
   },
   "dependencies": {
-    "pyright": "^1.1.303"
+    "pyright": "^1.1.304"
   }
 }