coc-pyright 1.1.291 → 1.1.292

package/lib/index.js

@@ -6580,7 +6580,6 @@ var require_parseNodes = __commonJS({
         case 27:
         case 48:
         case 15:
-        case 16:
         case 31:
         case 45:
           return true;
@@ -7692,6 +7691,425 @@ var require_parseNodes = __commonJS({
   }
 });
 
+// node_modules/@zzzen/pyright-internal/dist/parser/stringTokenUtils.js
+var require_stringTokenUtils = __commonJS({
+  "node_modules/@zzzen/pyright-internal/dist/parser/stringTokenUtils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getUnescapedString = exports.UnescapeErrorType = void 0;
+    var UnescapeErrorType;
+    (function(UnescapeErrorType2) {
+      UnescapeErrorType2[UnescapeErrorType2["InvalidEscapeSequence"] = 0] = "InvalidEscapeSequence";
+      UnescapeErrorType2[UnescapeErrorType2["EscapeWithinFormatExpression"] = 1] = "EscapeWithinFormatExpression";
+      UnescapeErrorType2[UnescapeErrorType2["SingleCloseBraceWithinFormatLiteral"] = 2] = "SingleCloseBraceWithinFormatLiteral";
+      UnescapeErrorType2[UnescapeErrorType2["UnterminatedFormatExpression"] = 3] = "UnterminatedFormatExpression";
+    })(UnescapeErrorType = exports.UnescapeErrorType || (exports.UnescapeErrorType = {}));
+    function completeUnescapedString(incomplete) {
+      return {
+        ...incomplete,
+        value: incomplete.valueParts.join(""),
+        formatStringSegments: incomplete.formatStringSegments.map((segment) => ({
+          ...segment,
+          value: segment.valueParts.join("")
+        }))
+      };
+    }
+    function getUnescapedString(stringToken) {
+      const escapedString = stringToken.escapedValue;
+      const isRaw = (stringToken.flags & 8) !== 0;
+      const isFormat = (stringToken.flags & 64) !== 0;
+      if (isRaw && !isFormat) {
+        return {
+          value: escapedString,
+          unescapeErrors: [],
+          nonAsciiInBytes: false,
+          formatStringSegments: []
+        };
+      }
+      const charCodes = [];
+      for (let index = 0; index < escapedString.length; index++) {
+        charCodes.push(escapedString.charCodeAt(index));
+      }
+      const isBytes = (stringToken.flags & 32) !== 0;
+      if (!isFormat) {
+        if (!charCodes.some((curChar) => curChar === 13 || curChar === 10 || curChar === 92)) {
+          return {
+            value: escapedString,
+            unescapeErrors: [],
+            nonAsciiInBytes: isBytes && charCodes.some((curChar) => curChar >= 128),
+            formatStringSegments: []
+          };
+        }
+      }
+      let formatExpressionNestCount = 0;
+      let formatSegment = {
+        offset: 0,
+        length: 0,
+        valueParts: [],
+        isExpression: false,
+        hasFormatSpecifier: false
+      };
+      let strOffset = 0;
+      const output = {
+        valueParts: [],
+        unescapeErrors: [],
+        nonAsciiInBytes: false,
+        formatStringSegments: []
+      };
+      const addInvalidEscapeOffset = () => {
+        if (!isRaw) {
+          output.unescapeErrors.push({
+            offset: strOffset - 1,
+            length: 2,
+            errorType: 0
+          });
+        }
+      };
+      const getEscapedCharacter = (offset = 0) => {
+        if (strOffset + offset >= charCodes.length) {
+          return 3;
+        }
+        return charCodes[strOffset + offset];
+      };
+      const scanHexEscape = (digitCount) => {
+        let foundIllegalHexDigit = false;
+        let hexValue = 0;
+        let localValue = "";
+        for (let i = 0; i < digitCount; i++) {
+          const charCode = getEscapedCharacter(1 + i);
+          if (!_isHexCharCode(charCode)) {
+            foundIllegalHexDigit = true;
+            break;
+          }
+          hexValue = 16 * hexValue + _getHexDigitValue(charCode);
+        }
+        if (foundIllegalHexDigit) {
+          addInvalidEscapeOffset();
+          localValue = "\\" + String.fromCharCode(getEscapedCharacter());
+          strOffset++;
+        } else {
+          localValue = String.fromCharCode(hexValue);
+          strOffset += 1 + digitCount;
+        }
+        return localValue;
+      };
+      const appendOutputChar = (charCode) => {
+        const char = String.fromCharCode(charCode);
+        output.valueParts.push(char);
+        formatSegment.valueParts.push(char);
+      };
+      while (true) {
+        let curChar = getEscapedCharacter();
+        if (curChar === 3) {
+          if (isFormat) {
+            if (formatSegment.isExpression) {
+              output.unescapeErrors.push({
+                offset: formatSegment.offset,
+                length: strOffset - formatSegment.offset,
+                errorType: 3
+              });
+            }
+            if (strOffset !== formatSegment.offset) {
+              formatSegment.length = strOffset - formatSegment.offset;
+              output.formatStringSegments.push(formatSegment);
+            }
+          }
+          return completeUnescapedString(output);
+        }
+        if (curChar === 92) {
+          if (isFormat && formatSegment.isExpression && !formatSegment.hasFormatSpecifier) {
+            output.unescapeErrors.push({
+              offset: strOffset,
+              length: 1,
+              errorType: 1
+            });
+          }
+          strOffset++;
+          if (isRaw) {
+            appendOutputChar(curChar);
+            continue;
+          }
+          curChar = getEscapedCharacter();
+          let localValue = "";
+          if (curChar === 13 || curChar === 10) {
+            if (curChar === 13 && getEscapedCharacter(1) === 10) {
+              if (isRaw) {
+                localValue += String.fromCharCode(curChar);
+              }
+              strOffset++;
+              curChar = getEscapedCharacter();
+            }
+            if (isRaw) {
+              localValue = "\\" + localValue + String.fromCharCode(curChar);
+            }
+            strOffset++;
+          } else {
+            if (isRaw || isFormat && formatSegment.isExpression) {
+              localValue = "\\" + String.fromCharCode(curChar);
+              strOffset++;
+            } else {
+              switch (curChar) {
+                case 92:
+                case 39:
+                case 34:
+                  localValue = String.fromCharCode(curChar);
+                  strOffset++;
+                  break;
+                case 97:
+                  localValue = "\x07";
+                  strOffset++;
+                  break;
+                case 98:
+                  localValue = "\b";
+                  strOffset++;
+                  break;
+                case 102:
+                  localValue = "\f";
+                  strOffset++;
+                  break;
+                case 110:
+                  localValue = "\n";
+                  strOffset++;
+                  break;
+                case 114:
+                  localValue = "\r";
+                  strOffset++;
+                  break;
+                case 116:
+                  localValue = "	";
+                  strOffset++;
+                  break;
+                case 118:
+                  localValue = "\v";
+                  strOffset++;
+                  break;
+                case 120:
+                  localValue = scanHexEscape(2);
+                  break;
+                case 78: {
+                  let foundIllegalChar = false;
+                  let charCount = 1;
+                  if (getEscapedCharacter(charCount) !== 123) {
+                    foundIllegalChar = true;
+                  } else {
+                    charCount++;
+                    while (true) {
+                      const lookaheadChar = getEscapedCharacter(charCount);
+                      if (lookaheadChar === 125) {
+                        break;
+                      } else if (!_isAlphaNumericChar(lookaheadChar) && lookaheadChar !== 45 && !_isWhitespaceChar(lookaheadChar)) {
+                        foundIllegalChar = true;
+                        break;
+                      } else {
+                        charCount++;
+                      }
+                    }
+                  }
+                  if (foundIllegalChar) {
+                    addInvalidEscapeOffset();
+                    localValue = "\\" + String.fromCharCode(curChar);
+                    strOffset++;
+                  } else {
+                    localValue = "-";
+                    strOffset += 1 + charCount;
+                  }
+                  break;
+                }
+                case 117:
+                  localValue = scanHexEscape(4);
+                  break;
+                case 85:
+                  localValue = scanHexEscape(8);
+                  break;
+                default:
+                  if (_isOctalCharCode(curChar)) {
+                    let octalCode = curChar - 48;
+                    strOffset++;
+                    curChar = getEscapedCharacter();
+                    if (_isOctalCharCode(curChar)) {
+                      octalCode = octalCode * 8 + curChar - 48;
+                      strOffset++;
+                      curChar = getEscapedCharacter();
+                      if (_isOctalCharCode(curChar)) {
+                        octalCode = octalCode * 8 + curChar - 48;
+                        strOffset++;
+                      }
+                    }
+                    localValue = String.fromCharCode(octalCode);
+                  } else {
+                    localValue = "\\";
+                    addInvalidEscapeOffset();
+                  }
+                  break;
+              }
+            }
+          }
+          output.valueParts.push(localValue);
+          formatSegment.valueParts.push(localValue);
+        } else if (curChar === 10 || curChar === 13) {
+          if (curChar === 13 && getEscapedCharacter(1) === 10) {
+            appendOutputChar(curChar);
+            strOffset++;
+            curChar = getEscapedCharacter();
+          }
+          appendOutputChar(curChar);
+          strOffset++;
+        } else if (isFormat && curChar === 123) {
+          if (!formatSegment.isExpression && getEscapedCharacter(1) === 123) {
+            appendOutputChar(curChar);
+            strOffset += 2;
+          } else {
+            if (formatExpressionNestCount === 0) {
+              formatSegment.length = strOffset - formatSegment.offset;
+              if (formatSegment.length > 0) {
+                output.formatStringSegments.push(formatSegment);
+              }
+              strOffset++;
+              formatSegment = {
+                offset: strOffset,
+                length: 0,
+                valueParts: [],
+                isExpression: true,
+                hasFormatSpecifier: false
+              };
+            } else {
+              appendOutputChar(curChar);
+              strOffset++;
+            }
+            formatExpressionNestCount++;
+          }
+        } else if (isFormat && curChar === 125) {
+          if (!formatSegment.isExpression && getEscapedCharacter(1) === 125) {
+            appendOutputChar(curChar);
+            strOffset += 2;
+          } else if (formatExpressionNestCount === 0) {
+            output.unescapeErrors.push({
+              offset: strOffset,
+              length: 1,
+              errorType: 2
+            });
+            strOffset++;
+          } else {
+            formatExpressionNestCount--;
+            if (formatExpressionNestCount === 0) {
+              formatSegment.length = strOffset - formatSegment.offset;
+              output.formatStringSegments.push(formatSegment);
+              strOffset++;
+              formatSegment = {
+                offset: strOffset,
+                length: 0,
+                valueParts: [],
+                isExpression: false,
+                hasFormatSpecifier: false
+              };
+            } else {
+              appendOutputChar(curChar);
+              strOffset++;
+            }
+          }
+        } else if (formatSegment.isExpression && (curChar === 39 || curChar === 34)) {
+          const quoteChar = curChar;
+          appendOutputChar(curChar);
+          const isTriplicate = getEscapedCharacter(1) === quoteChar && getEscapedCharacter(2) === quoteChar;
+          if (isTriplicate) {
+            strOffset += 2;
+            appendOutputChar(curChar);
+            appendOutputChar(curChar);
+            output.valueParts.push(String.fromCharCode(curChar));
+            output.valueParts.push(String.fromCharCode(curChar));
+          }
+          while (true) {
+            strOffset++;
+            let strChar = getEscapedCharacter();
+            if (strChar === 3) {
+              break;
+            }
+            if (strChar === 92) {
+              appendOutputChar(strChar);
+              strOffset++;
+              strChar = getEscapedCharacter();
+              appendOutputChar(strChar);
+              continue;
+            }
+            if (strChar === 10 || strChar === 13) {
+              if (!isTriplicate) {
+                break;
+              }
+            }
+            if (strChar === quoteChar) {
+              if (!isTriplicate) {
+                strOffset++;
+                appendOutputChar(strChar);
+                break;
+              }
+              if (getEscapedCharacter(1) === quoteChar && getEscapedCharacter(2) === quoteChar) {
+                strOffset += 3;
+                appendOutputChar(strChar);
+                appendOutputChar(strChar);
+                appendOutputChar(strChar);
+                break;
+              }
+            }
+            appendOutputChar(strChar);
+          }
+        } else {
+          if (formatSegment.isExpression && curChar === 58) {
+            formatSegment.hasFormatSpecifier = true;
+          }
+          if (isBytes && curChar >= 128) {
+            output.nonAsciiInBytes = true;
+          }
+          appendOutputChar(curChar);
+          strOffset++;
+        }
+      }
+    }
+    exports.getUnescapedString = getUnescapedString;
+    function _isWhitespaceChar(charCode) {
+      return charCode === 32 || charCode === 9;
+    }
+    function _isAlphaNumericChar(charCode) {
+      if (charCode >= 48 && charCode <= 57) {
+        return true;
+      }
+      if (charCode >= 97 && charCode <= 122) {
+        return true;
+      }
+      if (charCode >= 65 && charCode <= 90) {
+        return true;
+      }
+      return false;
+    }
+    function _isOctalCharCode(charCode) {
+      return charCode >= 48 && charCode <= 55;
+    }
+    function _isHexCharCode(charCode) {
+      if (charCode >= 48 && charCode <= 57) {
+        return true;
+      }
+      if (charCode >= 97 && charCode <= 102) {
+        return true;
+      }
+      if (charCode >= 65 && charCode <= 70) {
+        return true;
+      }
+      return false;
+    }
+    function _getHexDigitValue(charCode) {
+      if (charCode >= 48 && charCode <= 57) {
+        return charCode - 48;
+      }
+      if (charCode >= 97 && charCode <= 102) {
+        return charCode - 97 + 10;
+      }
+      if (charCode >= 65 && charCode <= 70) {
+        return charCode - 65 + 10;
+      }
+      return 0;
+    }
+  }
+});
+
 // node_modules/@zzzen/pyright-internal/dist/analyzer/parseTreeWalker.js
 var require_parseTreeWalker = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/analyzer/parseTreeWalker.js"(exports) {
@@ -8366,6 +8784,7 @@ var require_parseTreeUtils = __commonJS({
     var positionUtils_1 = require_positionUtils();
     var textRange_1 = require_textRange();
     var parseNodes_1 = require_parseNodes();
+    var StringTokenUtils = __importStar(require_stringTokenUtils());
     var analyzerNodeInfo_1 = require_analyzerNodeInfo();
     var parseTreeWalker_1 = require_parseTreeWalker();
     var PrintExpressionFlags;
@@ -9406,7 +9825,7 @@ var require_parseTreeUtils = __commonJS({
       let callNode;
       while (curNode !== void 0) {
         if (curNode.nodeType === 9) {
-          if (isOffsetInsideCallArgs(curNode, insertionOffset)) {
+          if (isOffsetInsideCallArgs(tokens, curNode, insertionOffset)) {
             callNode = curNode;
             break;
           }
@@ -9466,17 +9885,46 @@ var require_parseTreeUtils = __commonJS({
         activeIndex,
         activeOrFake
       };
-      function isOffsetInsideCallArgs(node2, offset) {
-        let found = true;
+      function isOffsetInsideCallArgs(tokens2, node2, offset) {
         const argumentStart = node2.leftExpression.length > 0 ? textRange_1.TextRange.getEnd(node2.leftExpression) - 1 : node2.leftExpression.start;
-        const index = tokens.getItemAtPosition(argumentStart);
-        if (index >= 0 && index + 1 < tokens.count) {
-          const token = tokens.getItemAt(index + 1);
-          if (token.type === 13 && insertionOffset < textRange_1.TextRange.getEnd(token)) {
-            found = false;
+        const callEndOffset = textRange_1.TextRange.getEnd(node2);
+        if (offset < argumentStart || callEndOffset < offset) {
+          return false;
+        }
+        if (node2.arguments.length > 0) {
+          const start = node2.arguments[0].start;
+          const end = textRange_1.TextRange.getEnd(node2.arguments[node2.arguments.length - 1]);
+          if (start <= offset && offset < end) {
+            return true;
           }
         }
-        return found;
+        const index = tokens2.getItemAtPosition(argumentStart);
+        if (index < 0 || tokens2.count <= index) {
+          return true;
+        }
+        const token = tokens2.getItemAt(index);
+        if (token.type === 5 && token.flags & 64 && textRange_1.TextRange.contains(token, offset)) {
+          const stringToken = token;
+          const result = StringTokenUtils.getUnescapedString(stringToken);
+          const offsetInSegment = offset - stringToken.start - stringToken.prefixLength - stringToken.quoteMarkLength;
+          const segment = result.formatStringSegments.find((s) => s.offset <= offsetInSegment && offsetInSegment < s.offset + s.length);
+          if (!segment || !segment.isExpression) {
+            return true;
+          }
+          const length = Math.min(segment.length, callEndOffset - stringToken.start - stringToken.prefixLength - stringToken.quoteMarkLength - segment.offset);
+          for (let i = offsetInSegment - segment.offset; i < length; i++) {
+            const ch = segment.value[i];
+            if (ch === "(") {
+              return false;
+            }
+          }
+          return true;
+        }
+        const nextToken = tokens2.getItemAt(index + 1);
+        if (nextToken.type === 13 && offset < textRange_1.TextRange.getEnd(nextToken)) {
+          return false;
+        }
+        return true;
       }
     }
     exports.getCallNodeAndActiveParameterIndex = getCallNodeAndActiveParameterIndex;
@@ -20921,7 +21369,7 @@ var require_configOptions = __commonJS({
       return result;
     };
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.ConfigOptions = exports.getStrictDiagnosticRuleSet = exports.getBasicDiagnosticRuleSet = exports.getOffDiagnosticRuleSet = exports.getStrictModeNotOverriddenRules = exports.getDiagLevelDiagnosticRules = exports.getBooleanDiagnosticRules = exports.cloneDiagnosticRuleSet = exports.ExecutionEnvironment = exports.PythonPlatform = void 0;
+    exports.ConfigOptions = exports.getStrictDiagnosticRuleSet = exports.getBasicDiagnosticRuleSet = exports.getOffDiagnosticRuleSet = exports.getStrictModeNotOverriddenRules = exports.getDiagLevelDiagnosticRules = exports.getBooleanDiagnosticRules = exports.cloneDiagnosticRuleSet = exports.SignatureDisplayType = exports.ExecutionEnvironment = exports.PythonPlatform = void 0;
     var path_1 = require("path");
     var pythonPathUtils_1 = require_pythonPathUtils();
     var pathConsts = __importStar(require_pathConsts());
@@ -20945,6 +21393,11 @@ var require_configOptions = __commonJS({
       }
     };
     exports.ExecutionEnvironment = ExecutionEnvironment;
+    var SignatureDisplayType;
+    (function(SignatureDisplayType2) {
+      SignatureDisplayType2["compact"] = "compact";
+      SignatureDisplayType2["formatted"] = "formatted";
+    })(SignatureDisplayType = exports.SignatureDisplayType || (exports.SignatureDisplayType = {}));
     function cloneDiagnosticRuleSet(diagSettings) {
       return Object.assign({}, diagSettings);
     }
@@ -21291,6 +21744,7 @@ var require_configOptions = __commonJS({
         this.projectRoot = projectRoot;
         this.typeCheckingMode = typeCheckingMode;
         this.diagnosticRuleSet = ConfigOptions.getDiagnosticRuleSet(typeCheckingMode);
+        this.functionSignatureDisplay = SignatureDisplayType.formatted;
       }
       static getDiagnosticRuleSet(typeCheckingMode) {
         if (typeCheckingMode === "strict") {
@@ -21562,6 +22016,15 @@ var require_configOptions = __commonJS({
             this.typeEvaluationTimeThreshold = configObj.typeEvaluationTimeThreshold;
           }
         }
+        if (configObj.functionSignatureDisplay !== void 0) {
+          if (typeof configObj.functionSignatureDisplay !== "string") {
+            console2.error(`Config "functionSignatureDisplay" field must be true or false.`);
+          } else {
+            if (configObj.functionSignatureDisplay === "compact" || configObj.functionSignatureDisplay === "formatted") {
+              this.functionSignatureDisplay = configObj.functionSignatureDisplay;
+            }
+          }
+        }
       }
       ensureDefaultPythonPlatform(host, console2) {
         if (this.defaultPythonPlatform !== void 0) {
@@ -23244,11 +23707,15 @@ var require_types = __commonJS({
     })(TypeFlags = exports.TypeFlags || (exports.TypeFlags = {}));
     exports.WildcardTypeVarScopeId = "*";
     var EnumLiteral = class {
-      constructor(className, itemName, itemType) {
+      constructor(classFullName, className, itemName, itemType) {
+        this.classFullName = classFullName;
         this.className = className;
         this.itemName = itemName;
         this.itemType = itemType;
       }
+      getName() {
+        return `${this.classFullName}.${this.itemName}`;
+      }
     };
     exports.EnumLiteral = EnumLiteral;
     exports.maxTypeRecursionCount = 32;
@@ -24371,6 +24838,12 @@ var require_types = __commonJS({
               unionType.literalIntMap = /* @__PURE__ */ new Map();
             }
             unionType.literalIntMap.set(newType.literalValue, newType);
+          } else if (ClassType.isEnumClass(newType)) {
+            if (unionType.literalEnumMap === void 0) {
+              unionType.literalEnumMap = /* @__PURE__ */ new Map();
+            }
+            const enumLiteral = newType.literalValue;
+            unionType.literalEnumMap.set(enumLiteral.getName(), newType);
           }
         }
         unionType.flags &= newType.flags;
@@ -24386,6 +24859,9 @@ var require_types = __commonJS({
             return unionType.literalStrMap.has(subtype.literalValue);
           } else if (ClassType.isBuiltIn(subtype, "int") && unionType.literalIntMap !== void 0) {
             return unionType.literalIntMap.has(subtype.literalValue);
+          } else if (ClassType.isEnumClass(subtype) && unionType.literalEnumMap !== void 0) {
+            const enumLiteral = subtype.literalValue;
+            return unionType.literalEnumMap.has(enumLiteral.getName());
           }
         }
         const foundIndex = unionType.subtypes.findIndex((t, i) => {
@@ -25051,6 +25527,12 @@ var require_types = __commonJS({
             UnionType.addType(unionType, typeToAdd);
           }
           return;
+        } else if (ClassType.isEnumClass(typeToAdd) && typeToAdd.literalValue !== void 0 && unionType.literalEnumMap !== void 0) {
+          const enumLiteral = typeToAdd.literalValue;
+          if (!unionType.literalEnumMap.has(enumLiteral.getName())) {
+            UnionType.addType(unionType, typeToAdd);
+          }
+          return;
         }
       }
       const isPseudoGeneric = isClass(typeToAdd) && ClassType.isPseudoGenericClass(typeToAdd);
@@ -25537,7 +26019,7 @@ var require_typeUtils = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/analyzer/typeUtils.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getTupleDepth = exports.getProtocolSymbols = exports.transformExpectedTypeForConstructor = exports.validateTypeVarDefault = exports.applySolvedTypeVars = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isUnboundedTupleClass = exports.isTupleClass = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.containsType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = 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.isIncompleteUnknown = exports.isOptionalType = exports.getParameterListDetails = exports.ParameterSource = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.ClassMemberLookupFlags = void 0;
+    exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbols = exports.transformExpectedTypeForConstructor = exports.validateTypeVarDefault = exports.applySolvedTypeVars = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isUnboundedTupleClass = exports.isTupleClass = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.containsType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = 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.isIncompleteUnknown = exports.isOptionalType = exports.getParameterListDetails = exports.ParameterSource = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.ClassMemberLookupFlags = void 0;
     exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.requiresSpecialization = exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.removeParamSpecVariadicsFromFunction = exports.removeParamSpecVariadicsFromSignature = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsUnknown = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = void 0;
     var collectionUtils_1 = require_collectionUtils();
     var debug_1 = require_debug2();
@@ -26293,24 +26775,35 @@ var require_typeUtils = __commonJS({
         }
       });
     }
-    function getTupleDepth(type, recursionCount = 0) {
+    function getContainerDepth(type, recursionCount = 0) {
       if (recursionCount > types_1.maxTypeRecursionCount) {
         return 1;
       }
       recursionCount++;
-      if (!(0, types_1.isClassInstance)(type) || !type.tupleTypeArguments) {
+      if (!(0, types_1.isClassInstance)(type)) {
         return 0;
       }
       let maxChildDepth = 0;
-      type.tupleTypeArguments.forEach((typeArgInfo) => {
-        doForEachSubtype(typeArgInfo.type, (subtype) => {
-          const childDepth = getTupleDepth(subtype, recursionCount);
-          maxChildDepth = Math.max(childDepth, maxChildDepth);
+      if (type.tupleTypeArguments) {
+        type.tupleTypeArguments.forEach((typeArgInfo) => {
+          doForEachSubtype(typeArgInfo.type, (subtype) => {
+            const childDepth = getContainerDepth(subtype, recursionCount);
+            maxChildDepth = Math.max(childDepth, maxChildDepth);
+          });
         });
-      });
+      } else if (type.typeArguments) {
+        type.typeArguments.forEach((typeArg) => {
+          doForEachSubtype(typeArg, (subtype) => {
+            const childDepth = getContainerDepth(subtype, recursionCount);
+            maxChildDepth = Math.max(childDepth, maxChildDepth);
+          });
+        });
+      } else {
+        return 0;
+      }
       return 1 + maxChildDepth;
     }
-    exports.getTupleDepth = getTupleDepth;
+    exports.getContainerDepth = getContainerDepth;
     function lookUpObjectMember(objectType, memberName, flags = 0) {
       if ((0, types_1.isClassInstance)(objectType)) {
         return lookUpClassMember(objectType, memberName, flags);
@@ -27443,6 +27936,7 @@ var require_typeUtils = __commonJS({
       constructor() {
         this._isTransformingTypeArg = false;
         this._pendingTypeVarTransformations = /* @__PURE__ */ new Set();
+        this._pendingFunctionTransformations = [];
       }
       apply(type, recursionCount) {
         var _a, _b;
@@ -27523,9 +28017,19 @@ var require_typeUtils = __commonJS({
           return this._transformTypeVarsInClassType(type, recursionCount);
         }
         if ((0, types_1.isFunction)(type)) {
-          return this._transformTypeVarsInFunctionType(type, recursionCount);
+          if (this._pendingFunctionTransformations.some((t) => t === type)) {
+            return type;
+          }
+          this._pendingFunctionTransformations.push(type);
+          const result = this._transformTypeVarsInFunctionType(type, recursionCount);
+          this._pendingFunctionTransformations.pop();
+          return result;
         }
         if ((0, types_1.isOverloadedFunction)(type)) {
+          if (this._pendingFunctionTransformations.some((t) => t === type)) {
+            return type;
+          }
+          this._pendingFunctionTransformations.push(type);
           let requiresUpdate = false;
           const newOverloads = [];
           type.overloads.forEach((entry) => {
@@ -27535,6 +28039,7 @@ var require_typeUtils = __commonJS({
               requiresUpdate = true;
             }
           });
+          this._pendingFunctionTransformations.pop();
           return requiresUpdate ? types_1.OverloadedFunctionType.create(newOverloads) : type;
         }
         return type;
@@ -30692,8 +31197,9 @@ var require_typedDicts = __commonJS({
     exports.getTypeOfIndexedTypedDict = getTypeOfIndexedTypedDict;
     function narrowForKeyAssignment(classType, key) {
       var _a;
-      (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
-      (0, debug_1.assert)(classType.details.typedDictEntries);
+      if (!types_1.ClassType.isTypedDictClass(classType) || !classType.details.typedDictEntries) {
+        return classType;
+      }
       const tdEntry = classType.details.typedDictEntries.get(key);
       if (!tdEntry || tdEntry.isRequired) {
         return classType;
@@ -33312,14 +33818,38 @@ var require_tooltipUtils = __commonJS({
       return result;
     };
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.getAutoImportText = exports.getDocumentationPartsForTypeAndDecl = exports.getOverloadedFunctionDocStringsFromType = exports.getFunctionDocStringFromType = exports.getOverloadedFunctionTooltip = void 0;
+    exports.getAutoImportText = exports.getDocumentationPartsForTypeAndDecl = exports.getOverloadedFunctionDocStringsFromType = exports.getFunctionDocStringFromType = exports.getConstructorTooltip = exports.getFunctionTooltip = exports.getOverloadedFunctionTooltip = exports.getToolTipForType = void 0;
     var ParseTreeUtils = __importStar(require_parseTreeUtils());
     var typeDocStringUtils_1 = require_typeDocStringUtils();
     var types_1 = require_types();
+    var configOptions_1 = require_configOptions();
     var core_1 = require_core();
-    function getOverloadedFunctionTooltip(type, evaluator, columnThreshold = 70) {
+    var functionParamIndentOffset = 4;
+    function getToolTipForType(type, label, name, evaluator, isProperty, functionSignatureDisplay) {
+      let signatureString = "";
+      if ((0, types_1.isOverloadedFunction)(type)) {
+        signatureString = label.length > 0 ? `(${label})
+` : "";
+        signatureString += `${getOverloadedFunctionTooltip(type, evaluator, functionSignatureDisplay)}`;
+      } else if ((0, types_1.isFunction)(type)) {
+        signatureString = `${getFunctionTooltip(label, name, type, evaluator, isProperty, functionSignatureDisplay)}`;
+      } else {
+        signatureString = label.length > 0 ? `(${label}) ` : "";
+        signatureString += `${name}: ${evaluator.printType(type)}`;
+      }
+      return signatureString;
+    }
+    exports.getToolTipForType = getToolTipForType;
+    function getOverloadedFunctionTooltip(type, evaluator, functionSignatureDisplay, columnThreshold = 70) {
       let content = "";
-      const overloads = types_1.OverloadedFunctionType.getOverloads(type).map((o) => o.details.name + evaluator.printType(o));
+      const overloads = types_1.OverloadedFunctionType.getOverloads(type).map((o) => getFunctionTooltip(
+        "",
+        o.details.name,
+        o,
+        evaluator,
+        false,
+        functionSignatureDisplay
+      ));
       for (let i = 0; i < overloads.length; i++) {
         if (i !== 0 && overloads[i].length > columnThreshold && overloads[i - 1].length <= columnThreshold) {
           content += "\n";
@@ -33335,6 +33865,35 @@ var require_tooltipUtils = __commonJS({
       return content;
     }
     exports.getOverloadedFunctionTooltip = getOverloadedFunctionTooltip;
+    function getFunctionTooltip(label, functionName, type, evaluator, isProperty = false, functionSignatureDisplay) {
+      const labelFormatted = label.length === 0 ? "" : `(${label}) `;
+      const indentStr = functionSignatureDisplay === configOptions_1.SignatureDisplayType.formatted ? "\n" + " ".repeat(functionParamIndentOffset) : "";
+      const funcParts = evaluator.printFunctionParts(type);
+      const paramSignature = formatSignature(funcParts, indentStr, functionSignatureDisplay);
+      const sep = isProperty ? ": " : "";
+      return `${labelFormatted}${functionName}${sep}${paramSignature} -> ${funcParts[1]}`;
+    }
+    exports.getFunctionTooltip = getFunctionTooltip;
+    function getConstructorTooltip(label, constructorName, type, evaluator, functionSignatureDisplay) {
+      let classText = label.length === 0 ? "" : `(${label}) `;
+      if ((0, types_1.isOverloadedFunction)(type)) {
+        const overloads = type.overloads.map((overload) => getConstructorTooltip("", constructorName, overload, evaluator, functionSignatureDisplay));
+        overloads.forEach((overload, index) => {
+          classText += overload + "\n\n";
+        });
+      } else if ((0, types_1.isFunction)(type)) {
+        const indentStr = functionSignatureDisplay === configOptions_1.SignatureDisplayType.formatted ? "\n" + " ".repeat(functionParamIndentOffset) : " ";
+        const funcParts = evaluator.printFunctionParts(type);
+        const paramSignature = formatSignature(funcParts, indentStr, functionSignatureDisplay);
+        classText += constructorName + paramSignature;
+      }
+      return classText;
+    }
+    exports.getConstructorTooltip = getConstructorTooltip;
+    function formatSignature(funcParts, indentStr, functionSignatureDisplay) {
+      return functionSignatureDisplay === configOptions_1.SignatureDisplayType.formatted && funcParts.length > 0 && funcParts[0].length > 1 ? `(${indentStr}${funcParts[0].join("," + indentStr)}
+)` : `(${funcParts[0].join(", ")})`;
+    }
     function getFunctionDocStringFromType(type, sourceMapper, evaluator) {
       const decl = type.details.declaration;
       const enclosingClass = decl ? ParseTreeUtils.getEnclosingClass(decl.node) : void 0;
@@ -34997,7 +35556,7 @@ ${methodBody}`;
               this._addSymbol(name, symbol, priorWord, completionMap, {
                 boundObjectOrClass,
                 funcParensDisabled: isInImport,
-                extraCommitChars: !isInImport
+                extraCommitChars: !isInImport && !!priorWord
               });
             }
           }
@@ -35120,13 +35679,14 @@ ${methodBody}`;
               ) || types_1.UnknownType.create();
               return name + ": " + this._evaluator.printType(propertyType) + " (property)";
             }
-            if ((0, types_1.isOverloadedFunction)(functionType)) {
-              return (0, tooltipUtils_1.getOverloadedFunctionTooltip)(functionType, this._evaluator, 35);
-            } else if ((0, types_1.isFunction)(functionType)) {
-              return name + this._evaluator.printType(functionType);
-            } else {
-              return name + ": " + this._evaluator.printType(functionType);
-            }
+            return (0, tooltipUtils_1.getToolTipForType)(
+              functionType,
+              "",
+              name,
+              this._evaluator,
+              false,
+              this._configOptions.functionSignatureDisplay
+            );
           }
           case 6:
           case 7: {
@@ -36191,7 +36751,7 @@ var require_hoverProvider = __commonJS({
     var textRange_1 = require_textRange();
     var tooltipUtils_1 = require_tooltipUtils();
     var HoverProvider = class {
-      static getHoverForPosition(sourceMapper, parseResults, position, format, evaluator, token) {
+      static getHoverForPosition(sourceMapper, parseResults, position, format, evaluator, functionSignatureDisplay, token) {
         var _a;
         (0, cancellationUtils_1.throwIfCancellationRequested)(token);
         const offset = (0, positionUtils_1.convertPositionToOffset)(position, parseResults.tokenizerOutput.lines);
@@ -36216,7 +36776,7 @@ var require_hoverProvider = __commonJS({
             if (primaryDeclaration.type === 8 && declarations.length > 1) {
               primaryDeclaration = declarations[1];
             }
-            this._addResultsForDeclaration(format, sourceMapper, results.parts, primaryDeclaration, node, evaluator);
+            this._addResultsForDeclaration(format, sourceMapper, results.parts, primaryDeclaration, node, evaluator, functionSignatureDisplay);
           } else if (!node.parent || node.parent.nodeType !== 37) {
             if (results.parts.length === 0) {
               const type = evaluator.getType(node) || types_1.UnknownType.create();
@@ -36245,7 +36805,7 @@ var require_hoverProvider = __commonJS({
         }
         return results.parts.length > 0 ? results : void 0;
       }
-      static _addResultsForDeclaration(format, sourceMapper, parts, declaration, node, evaluator) {
+      static _addResultsForDeclaration(format, sourceMapper, parts, declaration, node, evaluator, functionSignatureDisplay) {
         var _a;
         const resolvedDecl = evaluator.resolveAliasDeclaration(declaration, true);
         if (!resolvedDecl) {
@@ -36316,7 +36876,7 @@ var require_hoverProvider = __commonJS({
           }
           case 6:
           case 7: {
-            if (this._addInitOrNewMethodInsteadIfCallNode(format, node, evaluator, parts, sourceMapper, resolvedDecl)) {
+            if (this._addInitOrNewMethodInsteadIfCallNode(format, node, evaluator, parts, sourceMapper, resolvedDecl, functionSignatureDisplay)) {
               return;
             }
             this._addResultsPart(parts, "(class) " + node.value, true);
@@ -36332,29 +36892,10 @@ var require_hoverProvider = __commonJS({
               label = isProperty ? "property" : "method";
             }
             let type = evaluator.getType(node);
-            const sep = isProperty ? ": " : "";
             if (type) {
               type = this._limitOverloadBasedOnCall(node, evaluator, type);
-              if ((0, types_1.isOverloadedFunction)(type)) {
-                this._addResultsPart(
-                  parts,
-                  `(${label})
-${(0, tooltipUtils_1.getOverloadedFunctionTooltip)(type, evaluator)}`,
-                  true
-                );
-              } else if ((0, types_1.isFunction)(type)) {
-                this._addResultsPart(
-                  parts,
-                  `(${label}) ${node.value}${sep}${evaluator.printType(type)}`,
-                  true
-                );
-              } else {
-                this._addResultsPart(
-                  parts,
-                  `(${label}) ${node.value}: ${evaluator.printType(type)}`,
-                  true
-                );
-              }
+              const signatureString = (0, tooltipUtils_1.getToolTipForType)(type, label, node.value, evaluator, isProperty, functionSignatureDisplay);
+              this._addResultsPart(parts, signatureString, true);
             }
             this._addDocumentationPart(format, sourceMapper, parts, node, evaluator, resolvedDecl);
             break;
@@ -36396,7 +36937,7 @@ ${(0, tooltipUtils_1.getOverloadedFunctionTooltip)(type, evaluator)}`,
           }
         });
       }
-      static _addInitOrNewMethodInsteadIfCallNode(format, node, evaluator, parts, sourceMapper, declaration) {
+      static _addInitOrNewMethodInsteadIfCallNode(format, node, evaluator, parts, sourceMapper, declaration, functionSignatureDisplay) {
         var _a, _b;
         let callLeftNode = node;
         if (((_a = callLeftNode === null || callLeftNode === void 0 ? void 0 : callLeftNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 35 && node === callLeftNode.parent.memberName) {
@@ -36440,19 +36981,12 @@ ${(0, tooltipUtils_1.getOverloadedFunctionTooltip)(type, evaluator)}`,
           }
         }
         if (methodType && ((0, types_1.isFunction)(methodType) || (0, types_1.isOverloadedFunction)(methodType))) {
-          let classText = "";
-          if ((0, types_1.isOverloadedFunction)(methodType)) {
-            const overloads = methodType.overloads.map((overload) => evaluator.printFunctionParts(overload));
-            overloads.forEach((overload, index) => {
-              classText = classText + `${node.value}(${overload[0].join(", ")})
-
-`;
-            });
-          } else if ((0, types_1.isFunction)(methodType)) {
-            const functionParts = evaluator.printFunctionParts(methodType);
-            classText = `${node.value}(${functionParts[0].join(", ")})`;
-          }
-          this._addResultsPart(parts, "(class) " + classText, true);
+          methodType = this._limitOverloadBasedOnCall(node, evaluator, methodType);
+          this._addResultsPart(
+            parts,
+            (0, tooltipUtils_1.getConstructorTooltip)("class", node.value, methodType, evaluator, functionSignatureDisplay),
+            true
+          );
           const addedDoc = this._addDocumentationPartForType(format, sourceMapper, parts, methodType, declaration, evaluator);
           if (!addedDoc) {
             this._addDocumentationPartForType(format, sourceMapper, parts, classType, declaration, evaluator);
@@ -38604,7 +39138,7 @@ var require_binder = __commonJS({
                   node: importSymbolNode,
                   path: implicitImport.path,
                   loadSymbolsFromPath: true,
-                  range: (0, positionUtils_1.convertTextRangeToRange)(importSymbolNode, this._fileInfo.lines),
+                  range: (0, textRange_1.getEmptyRange)(),
                   usesLocalName: false,
                   moduleName: this._fileInfo.moduleName,
                   isInExceptSuite: this._isInExceptSuite
@@ -40285,425 +40819,6 @@ var require_binder = __commonJS({
   }
 });
 
-// node_modules/@zzzen/pyright-internal/dist/parser/stringTokenUtils.js
-var require_stringTokenUtils = __commonJS({
-  "node_modules/@zzzen/pyright-internal/dist/parser/stringTokenUtils.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.getUnescapedString = exports.UnescapeErrorType = void 0;
-    var UnescapeErrorType;
-    (function(UnescapeErrorType2) {
-      UnescapeErrorType2[UnescapeErrorType2["InvalidEscapeSequence"] = 0] = "InvalidEscapeSequence";
-      UnescapeErrorType2[UnescapeErrorType2["EscapeWithinFormatExpression"] = 1] = "EscapeWithinFormatExpression";
-      UnescapeErrorType2[UnescapeErrorType2["SingleCloseBraceWithinFormatLiteral"] = 2] = "SingleCloseBraceWithinFormatLiteral";
-      UnescapeErrorType2[UnescapeErrorType2["UnterminatedFormatExpression"] = 3] = "UnterminatedFormatExpression";
-    })(UnescapeErrorType = exports.UnescapeErrorType || (exports.UnescapeErrorType = {}));
-    function completeUnescapedString(incomplete) {
-      return {
-        ...incomplete,
-        value: incomplete.valueParts.join(""),
-        formatStringSegments: incomplete.formatStringSegments.map((segment) => ({
-          ...segment,
-          value: segment.valueParts.join("")
-        }))
-      };
-    }
-    function getUnescapedString(stringToken) {
-      const escapedString = stringToken.escapedValue;
-      const isRaw = (stringToken.flags & 8) !== 0;
-      const isFormat = (stringToken.flags & 64) !== 0;
-      if (isRaw && !isFormat) {
-        return {
-          value: escapedString,
-          unescapeErrors: [],
-          nonAsciiInBytes: false,
-          formatStringSegments: []
-        };
-      }
-      const charCodes = [];
-      for (let index = 0; index < escapedString.length; index++) {
-        charCodes.push(escapedString.charCodeAt(index));
-      }
-      const isBytes = (stringToken.flags & 32) !== 0;
-      if (!isFormat) {
-        if (!charCodes.some((curChar) => curChar === 13 || curChar === 10 || curChar === 92)) {
-          return {
-            value: escapedString,
-            unescapeErrors: [],
-            nonAsciiInBytes: isBytes && charCodes.some((curChar) => curChar >= 128),
-            formatStringSegments: []
-          };
-        }
-      }
-      let formatExpressionNestCount = 0;
-      let formatSegment = {
-        offset: 0,
-        length: 0,
-        valueParts: [],
-        isExpression: false,
-        hasFormatSpecifier: false
-      };
-      let strOffset = 0;
-      const output = {
-        valueParts: [],
-        unescapeErrors: [],
-        nonAsciiInBytes: false,
-        formatStringSegments: []
-      };
-      const addInvalidEscapeOffset = () => {
-        if (!isRaw) {
-          output.unescapeErrors.push({
-            offset: strOffset - 1,
-            length: 2,
-            errorType: 0
-          });
-        }
-      };
-      const getEscapedCharacter = (offset = 0) => {
-        if (strOffset + offset >= charCodes.length) {
-          return 3;
-        }
-        return charCodes[strOffset + offset];
-      };
-      const scanHexEscape = (digitCount) => {
-        let foundIllegalHexDigit = false;
-        let hexValue = 0;
-        let localValue = "";
-        for (let i = 0; i < digitCount; i++) {
-          const charCode = getEscapedCharacter(1 + i);
-          if (!_isHexCharCode(charCode)) {
-            foundIllegalHexDigit = true;
-            break;
-          }
-          hexValue = 16 * hexValue + _getHexDigitValue(charCode);
-        }
-        if (foundIllegalHexDigit) {
-          addInvalidEscapeOffset();
-          localValue = "\\" + String.fromCharCode(getEscapedCharacter());
-          strOffset++;
-        } else {
-          localValue = String.fromCharCode(hexValue);
-          strOffset += 1 + digitCount;
-        }
-        return localValue;
-      };
-      const appendOutputChar = (charCode) => {
-        const char = String.fromCharCode(charCode);
-        output.valueParts.push(char);
-        formatSegment.valueParts.push(char);
-      };
-      while (true) {
-        let curChar = getEscapedCharacter();
-        if (curChar === 3) {
-          if (isFormat) {
-            if (formatSegment.isExpression) {
-              output.unescapeErrors.push({
-                offset: formatSegment.offset,
-                length: strOffset - formatSegment.offset,
-                errorType: 3
-              });
-            }
-            if (strOffset !== formatSegment.offset) {
-              formatSegment.length = strOffset - formatSegment.offset;
-              output.formatStringSegments.push(formatSegment);
-            }
-          }
-          return completeUnescapedString(output);
-        }
-        if (curChar === 92) {
-          if (isFormat && formatSegment.isExpression && !formatSegment.hasFormatSpecifier) {
-            output.unescapeErrors.push({
-              offset: strOffset,
-              length: 1,
-              errorType: 1
-            });
-          }
-          strOffset++;
-          if (isRaw) {
-            appendOutputChar(curChar);
-            continue;
-          }
-          curChar = getEscapedCharacter();
-          let localValue = "";
-          if (curChar === 13 || curChar === 10) {
-            if (curChar === 13 && getEscapedCharacter(1) === 10) {
-              if (isRaw) {
-                localValue += String.fromCharCode(curChar);
-              }
-              strOffset++;
-              curChar = getEscapedCharacter();
-            }
-            if (isRaw) {
-              localValue = "\\" + localValue + String.fromCharCode(curChar);
-            }
-            strOffset++;
-          } else {
-            if (isRaw || isFormat && formatSegment.isExpression) {
-              localValue = "\\" + String.fromCharCode(curChar);
-              strOffset++;
-            } else {
-              switch (curChar) {
-                case 92:
-                case 39:
-                case 34:
-                  localValue = String.fromCharCode(curChar);
-                  strOffset++;
-                  break;
-                case 97:
-                  localValue = "\x07";
-                  strOffset++;
-                  break;
-                case 98:
-                  localValue = "\b";
-                  strOffset++;
-                  break;
-                case 102:
-                  localValue = "\f";
-                  strOffset++;
-                  break;
-                case 110:
-                  localValue = "\n";
-                  strOffset++;
-                  break;
-                case 114:
-                  localValue = "\r";
-                  strOffset++;
-                  break;
-                case 116:
-                  localValue = "	";
-                  strOffset++;
-                  break;
-                case 118:
-                  localValue = "\v";
-                  strOffset++;
-                  break;
-                case 120:
-                  localValue = scanHexEscape(2);
-                  break;
-                case 78: {
-                  let foundIllegalChar = false;
-                  let charCount = 1;
-                  if (getEscapedCharacter(charCount) !== 123) {
-                    foundIllegalChar = true;
-                  } else {
-                    charCount++;
-                    while (true) {
-                      const lookaheadChar = getEscapedCharacter(charCount);
-                      if (lookaheadChar === 125) {
-                        break;
-                      } else if (!_isAlphaNumericChar(lookaheadChar) && lookaheadChar !== 45 && !_isWhitespaceChar(lookaheadChar)) {
-                        foundIllegalChar = true;
-                        break;
-                      } else {
-                        charCount++;
-                      }
-                    }
-                  }
-                  if (foundIllegalChar) {
-                    addInvalidEscapeOffset();
-                    localValue = "\\" + String.fromCharCode(curChar);
-                    strOffset++;
-                  } else {
-                    localValue = "-";
-                    strOffset += 1 + charCount;
-                  }
-                  break;
-                }
-                case 117:
-                  localValue = scanHexEscape(4);
-                  break;
-                case 85:
-                  localValue = scanHexEscape(8);
-                  break;
-                default:
-                  if (_isOctalCharCode(curChar)) {
-                    let octalCode = curChar - 48;
-                    strOffset++;
-                    curChar = getEscapedCharacter();
-                    if (_isOctalCharCode(curChar)) {
-                      octalCode = octalCode * 8 + curChar - 48;
-                      strOffset++;
-                      curChar = getEscapedCharacter();
-                      if (_isOctalCharCode(curChar)) {
-                        octalCode = octalCode * 8 + curChar - 48;
-                        strOffset++;
-                      }
-                    }
-                    localValue = String.fromCharCode(octalCode);
-                  } else {
-                    localValue = "\\";
-                    addInvalidEscapeOffset();
-                  }
-                  break;
-              }
-            }
-          }
-          output.valueParts.push(localValue);
-          formatSegment.valueParts.push(localValue);
-        } else if (curChar === 10 || curChar === 13) {
-          if (curChar === 13 && getEscapedCharacter(1) === 10) {
-            appendOutputChar(curChar);
-            strOffset++;
-            curChar = getEscapedCharacter();
-          }
-          appendOutputChar(curChar);
-          strOffset++;
-        } else if (isFormat && curChar === 123) {
-          if (!formatSegment.isExpression && getEscapedCharacter(1) === 123) {
-            appendOutputChar(curChar);
-            strOffset += 2;
-          } else {
-            if (formatExpressionNestCount === 0) {
-              formatSegment.length = strOffset - formatSegment.offset;
-              if (formatSegment.length > 0) {
-                output.formatStringSegments.push(formatSegment);
-              }
-              strOffset++;
-              formatSegment = {
-                offset: strOffset,
-                length: 0,
-                valueParts: [],
-                isExpression: true,
-                hasFormatSpecifier: false
-              };
-            } else {
-              appendOutputChar(curChar);
-              strOffset++;
-            }
-            formatExpressionNestCount++;
-          }
-        } else if (isFormat && curChar === 125) {
-          if (!formatSegment.isExpression && getEscapedCharacter(1) === 125) {
-            appendOutputChar(curChar);
-            strOffset += 2;
-          } else if (formatExpressionNestCount === 0) {
-            output.unescapeErrors.push({
-              offset: strOffset,
-              length: 1,
-              errorType: 2
-            });
-            strOffset++;
-          } else {
-            formatExpressionNestCount--;
-            if (formatExpressionNestCount === 0) {
-              formatSegment.length = strOffset - formatSegment.offset;
-              output.formatStringSegments.push(formatSegment);
-              strOffset++;
-              formatSegment = {
-                offset: strOffset,
-                length: 0,
-                valueParts: [],
-                isExpression: false,
-                hasFormatSpecifier: false
-              };
-            } else {
-              appendOutputChar(curChar);
-              strOffset++;
-            }
-          }
-        } else if (formatSegment.isExpression && (curChar === 39 || curChar === 34)) {
-          const quoteChar = curChar;
-          appendOutputChar(curChar);
-          const isTriplicate = getEscapedCharacter(1) === quoteChar && getEscapedCharacter(2) === quoteChar;
-          if (isTriplicate) {
-            strOffset += 2;
-            appendOutputChar(curChar);
-            appendOutputChar(curChar);
-            output.valueParts.push(String.fromCharCode(curChar));
-            output.valueParts.push(String.fromCharCode(curChar));
-          }
-          while (true) {
-            strOffset++;
-            let strChar = getEscapedCharacter();
-            if (strChar === 3) {
-              break;
-            }
-            if (strChar === 92) {
-              appendOutputChar(strChar);
-              strOffset++;
-              strChar = getEscapedCharacter();
-              appendOutputChar(strChar);
-              continue;
-            }
-            if (strChar === 10 || strChar === 13) {
-              if (!isTriplicate) {
-                break;
-              }
-            }
-            if (strChar === quoteChar) {
-              if (!isTriplicate) {
-                strOffset++;
-                appendOutputChar(strChar);
-                break;
-              }
-              if (getEscapedCharacter(1) === quoteChar && getEscapedCharacter(2) === quoteChar) {
-                strOffset += 3;
-                appendOutputChar(strChar);
-                appendOutputChar(strChar);
-                appendOutputChar(strChar);
-                break;
-              }
-            }
-            appendOutputChar(strChar);
-          }
-        } else {
-          if (formatSegment.isExpression && curChar === 58) {
-            formatSegment.hasFormatSpecifier = true;
-          }
-          if (isBytes && curChar >= 128) {
-            output.nonAsciiInBytes = true;
-          }
-          appendOutputChar(curChar);
-          strOffset++;
-        }
-      }
-    }
-    exports.getUnescapedString = getUnescapedString;
-    function _isWhitespaceChar(charCode) {
-      return charCode === 32 || charCode === 9;
-    }
-    function _isAlphaNumericChar(charCode) {
-      if (charCode >= 48 && charCode <= 57) {
-        return true;
-      }
-      if (charCode >= 97 && charCode <= 122) {
-        return true;
-      }
-      if (charCode >= 65 && charCode <= 90) {
-        return true;
-      }
-      return false;
-    }
-    function _isOctalCharCode(charCode) {
-      return charCode >= 48 && charCode <= 55;
-    }
-    function _isHexCharCode(charCode) {
-      if (charCode >= 48 && charCode <= 57) {
-        return true;
-      }
-      if (charCode >= 97 && charCode <= 102) {
-        return true;
-      }
-      if (charCode >= 65 && charCode <= 70) {
-        return true;
-      }
-      return false;
-    }
-    function _getHexDigitValue(charCode) {
-      if (charCode >= 48 && charCode <= 57) {
-        return charCode - 48;
-      }
-      if (charCode >= 97 && charCode <= 102) {
-        return charCode - 97 + 10;
-      }
-      if (charCode >= 65 && charCode <= 70) {
-        return charCode - 65 + 10;
-      }
-      return 0;
-    }
-  }
-});
-
 // node_modules/@zzzen/pyright-internal/dist/parser/unicode.js
 var require_unicode = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/parser/unicode.js"(exports) {
@@ -45827,7 +45942,8 @@ var require_importResolver = __commonJS({
                 isStubFile,
                 isNativeLib: false,
                 name: dirName,
-                path: path12
+                path: path12,
+                pyTypedInfo: (0, pyTypedUtils_1.getPyTypedInfo)(this.fileSystem, (0, pathUtils_1.combinePaths)(dirPath, dirName))
               };
               implicitImportMap.set(implicitImport.name, implicitImport);
             }
@@ -45961,7 +46077,7 @@ var require_constraintSolver = __commonJS({
             void 0,
             void 0,
             void 0,
-            flags,
+            flags & ~1,
             recursionCount
           )) {
             return true;
@@ -47485,8 +47601,8 @@ var require_typeGuards = __commonJS({
       if ((0, types_1.isNever)(filteredType) && anyOrUnknownSubstitutions.length > 0) {
         return (0, types_1.combineTypes)(anyOrUnknownSubstitutions);
       }
-      if (anyOrUnknown.length > 0) {
-        return (0, types_1.combineTypes)([filteredType, ...anyOrUnknown]);
+      if ((0, types_1.isNever)(filteredType) && anyOrUnknown.length > 0) {
+        return (0, types_1.combineTypes)(anyOrUnknown);
       }
       return filteredType;
     }
@@ -48311,7 +48427,7 @@ var require_patternMatching = __commonJS({
               return types_1.NeverType.createNever();
             }
             if ((0, types_1.isAnyOrUnknown)(valueSubtypeExpanded) || (0, types_1.isAnyOrUnknown)(subjectSubtypeExpanded)) {
-              return (0, types_1.isUnknown)(valueSubtypeExpanded) || (0, types_1.isUnknown)(subjectSubtypeExpanded) ? types_1.UnknownType.create() : types_1.AnyType.create();
+              return (0, types_1.isUnknown)(valueSubtypeExpanded) || (0, types_1.isUnknown)(subjectSubtypeExpanded) ? (0, typeUtils_1.preserveUnknown)(valueSubtypeExpanded, subjectSubtypeExpanded) : types_1.AnyType.create();
             }
             const returnType = evaluator.useSpeculativeMode(pattern.expression, () => evaluator.getTypeOfMagicMethodReturn(
               valueSubtypeExpanded,
@@ -51375,7 +51491,7 @@ var require_enums = __commonJS({
         isMemberOfEnumeration = false;
       }
       if (isMemberOfEnumeration) {
-        const enumLiteral = new types_1.EnumLiteral(enumClassInfo.classType.details.name, node.value, valueType);
+        const enumLiteral = new types_1.EnumLiteral(enumClassInfo.classType.details.fullName, enumClassInfo.classType.details.name, node.value, valueType);
         return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneWithLiteral(enumClassInfo.classType, enumLiteral));
       }
       return void 0;
@@ -52480,6 +52596,7 @@ var require_typeEvaluator = __commonJS({
     var maxEffectiveTypeEvaluationAttempts = 16;
     var maxOverloadUnionExpansionCount = 64;
     var maxInferFunctionReturnRecursionCount = 12;
+    var maxInferredContainerDepth = 8;
     var maxRecursiveTypeAliasRecursionCount = 10;
     var verifyTypeCacheEvaluatorFlags = false;
     var printExpressionTypes = false;
@@ -56604,8 +56721,7 @@ var require_typeEvaluator = __commonJS({
         }
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults)));
         if (isIncomplete) {
-          const maxInferredTupleDepth = 8;
-          if ((0, typeUtils_1.getTupleDepth)(type) > maxInferredTupleDepth) {
+          if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
             return { type: types_1.UnknownType.create() };
           }
         }
@@ -59923,6 +60039,11 @@ var require_typeEvaluator = __commonJS({
           void 0,
           isEmptyContainer
         )) : types_1.UnknownType.create();
+        if (isIncomplete) {
+          if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+            return { type: types_1.UnknownType.create() };
+          }
+        }
         return { type, isIncomplete };
       }
       function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
@@ -60195,6 +60316,11 @@ var require_typeEvaluator = __commonJS({
           void 0,
           isEmptyContainer
         )) : types_1.UnknownType.create();
+        if (isIncomplete) {
+          if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+            return { type: types_1.UnknownType.create() };
+          }
+        }
         return { type, isIncomplete, typeErrors };
       }
       function verifySetEntryOrDictKeyIsHashable(entry, type, isDictKey) {
@@ -64776,6 +64902,13 @@ var require_typeEvaluator = __commonJS({
               declIndexToConsider = index;
             }
           });
+        } else {
+          if (decls.length > 1 && decls.every((decl) => decl.type === 8)) {
+            const nonExceptDecls = decls.filter((decl) => decl.type === 8 && !decl.isInExceptSuite);
+            if (nonExceptDecls.length === 1) {
+              declIndexToConsider = decls.findIndex((decl) => decl === nonExceptDecls[0]);
+            }
+          }
         }
         let sawExplicitTypeAlias = false;
         decls.forEach((decl, index) => {
@@ -65936,7 +66069,27 @@ var require_typeEvaluator = __commonJS({
         }
         if ((0, types_1.isOverloadedFunction)(destType)) {
           const overloadDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
-          const isAssignable = types_1.OverloadedFunctionType.getOverloads(destType).every((destOverload) => {
+          const destOverloads = types_1.OverloadedFunctionType.getOverloads(destType);
+          if ((0, types_1.isOverloadedFunction)(srcType)) {
+            const srcOverloads = types_1.OverloadedFunctionType.getOverloads(srcType);
+            if (destOverloads.length === srcOverloads.length) {
+              if (destOverloads.every((destOverload, index) => {
+                const srcOverload = srcOverloads[index];
+                return assignType(
+                  destOverload,
+                  srcOverload,
+                  void 0,
+                  destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destOverload)),
+                  srcTypeVarContext,
+                  flags,
+                  recursionCount
+                );
+              })) {
+                return true;
+              }
+            }
+          }
+          const isAssignable = destOverloads.every((destOverload) => {
             if (destTypeVarContext) {
               destTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(destOverload));
             }
@@ -68257,6 +68410,10 @@ var require_checker = __commonJS({
           if (!ParseTreeUtils.isWithinAssertExpression(node)) {
             this._validateComparisonTypes(node);
           }
+        } else if (node.operator === 39 || node.operator === 40) {
+          if (!ParseTreeUtils.isWithinAssertExpression(node)) {
+            this._validateComparisonTypesForIsOperator(node);
+          }
         } else if (node.operator === 41 || node.operator === 42) {
           if (!ParseTreeUtils.isWithinAssertExpression(node)) {
             this._validateContainmentTypes(node);
@@ -68596,6 +68753,32 @@ var require_checker = __commonJS({
           }), node);
         }
       }
+      _validateComparisonTypesForIsOperator(node) {
+        const rightType = this._evaluator.getType(node.rightExpression);
+        if (!rightType || !(0, types_1.isNoneInstance)(rightType)) {
+          return;
+        }
+        const leftType = this._evaluator.getType(node.leftExpression);
+        if (!leftType) {
+          return;
+        }
+        let foundMatchForNone = false;
+        (0, typeUtils_1.doForEachSubtype)(leftType, (subtype) => {
+          subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
+          if (this._evaluator.assignType(subtype, types_1.NoneType.createInstance())) {
+            foundMatchForNone = true;
+          }
+        });
+        const getMessage = () => {
+          return node.operator === 39 ? localize_1.Localizer.Diagnostic.comparisonAlwaysFalse() : localize_1.Localizer.Diagnostic.comparisonAlwaysTrue();
+        };
+        if (!foundMatchForNone) {
+          this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
+            leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
+            rightType: this._evaluator.printType(rightType)
+          }), node);
+        }
+      }
       _validateComparisonTypes(node) {
         let rightExpression = node.rightExpression;
         if (rightExpression.nodeType === 7 && !rightExpression.parenthesized && ParseTreeUtils.operatorSupportsChaining(rightExpression.operator)) {
@@ -71974,11 +72157,11 @@ var require_sourceFile = __commonJS({
         }
         return documentSymbolProvider_1.DocumentSymbolProvider.getSymbolsForDocument(this._parseResults ? AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree) : void 0, this.getCachedIndexResults(), this._parseResults, this._filePath, query, token);
       }
-      getHoverForPosition(sourceMapper, position, format, evaluator, token) {
+      getHoverForPosition(sourceMapper, position, format, evaluator, functionSignatureDisplay, token) {
         if (this._isBindingNeeded || !this._parseResults) {
           return void 0;
         }
-        return hoverProvider_1.HoverProvider.getHoverForPosition(sourceMapper, this._parseResults, position, format, evaluator, token);
+        return hoverProvider_1.HoverProvider.getHoverForPosition(sourceMapper, this._parseResults, position, format, evaluator, functionSignatureDisplay, token);
       }
       getDocumentHighlight(sourceMapper, position, evaluator, token) {
         if (this._isBindingNeeded || !this._parseResults) {
@@ -94957,8 +95140,9 @@ var BaseLinter = class {
     }
     return 3 /* Information */;
   }
-  async stdinRun(args, document) {
-    const child = (0, import_child_process3.spawn)(this.info.pathName(), args, { cwd: import_coc13.workspace.root });
+  async stdinRun(executionInfo, document) {
+    const { execPath, args } = executionInfo;
+    const child = (0, import_child_process3.spawn)(execPath, args, { cwd: import_coc13.workspace.root });
     return new Promise((resolve) => {
       child.stdin.setDefaultEncoding("utf8");
       child.stdin.write(document.getText());
@@ -94977,14 +95161,14 @@ var BaseLinter = class {
       return [];
     }
     try {
+      const executionInfo = this.info.getExecutionInfo(args, import_coc13.Uri.parse(document.uri));
       this.outputChannel.appendLine(`${"#".repeat(10)} Run linter ${this.info.id}:`);
-      this.outputChannel.appendLine(`${this.info.pathName()} ${args.join(" ")}`);
+      this.outputChannel.appendLine(JSON.stringify(executionInfo));
       this.outputChannel.appendLine("");
       let result = "";
       if (this.info.stdinSupport) {
-        result = await this.stdinRun(args, document);
+        result = await this.stdinRun(executionInfo, document);
       } else {
-        const executionInfo = this.info.getExecutionInfo(args, import_coc13.Uri.parse(document.uri));
         const pythonToolsExecutionService = new PythonExecutionService();
         result = (await pythonToolsExecutionService.exec(executionInfo, { cwd: import_coc13.workspace.root, token, mergeStdOutErr: false })).stdout;
       }
@@ -95459,7 +95643,7 @@ var Ruff = class extends BaseLinter {
   }
   async runLinter(document, token) {
     const fsPath = import_coc24.Uri.parse(document.uri).fsPath;
-    const args = [...this.info.linterArgs(), "--format", "json", "--exit-zero", "--stdin-filename", fsPath, "-"];
+    const args = ["--format", "json", "--exit-zero", "--stdin-filename", fsPath, "-"];
     return this.run(args, document, token);
   }
 };