coc-pyright 1.1.395 → 1.1.400

package/lib/index.js

@@ -518,6 +518,7 @@ var require_core = __commonJS({
     exports2.isDefined = isDefined;
     exports2.getEnumNames = getEnumNames;
     exports2.containsOnlyWhitespace = containsOnlyWhitespace;
+    exports2.cloneStr = cloneStr;
     var textRange_1 = require_textRange();
     var Comparison;
     (function(Comparison2) {
@@ -606,6 +607,9 @@ var require_core = __commonJS({
       }
       return /^\s*$/.test(text);
     }
+    function cloneStr(str) {
+      return Buffer.from(str, "utf8").toString("utf8");
+    }
     var Disposable;
     (function(Disposable2) {
       function is(value) {
@@ -2155,6 +2159,7 @@ var require_serviceKeys = __commonJS({
       ServiceKeys2.docStringService = new serviceProvider_1.ServiceKey();
       ServiceKeys2.windowService = new serviceProvider_1.ServiceKey();
       ServiceKeys2.commandService = new serviceProvider_1.ServiceKey();
+      ServiceKeys2.cancellationProvider = new serviceProvider_1.ServiceKey();
     })(ServiceKeys || (exports2.ServiceKeys = ServiceKeys = {}));
   }
 });
@@ -3201,6 +3206,7 @@ var require_diagnostic = __commonJS({
         this.range = range;
         this.priority = priority;
         this._relatedInfo = [];
+        this._data = null;
       }
       toJsonObj() {
         return {
@@ -3210,6 +3216,7 @@ var require_diagnostic = __commonJS({
           priority: this.priority,
           actions: this._actions,
           rule: this._rule,
+          data: this._data,
           relatedInfo: this._relatedInfo.map((info) => DiagnosticRelatedInfo.toJsonObj(info))
         };
       }
@@ -3218,6 +3225,7 @@ var require_diagnostic = __commonJS({
         diag._actions = obj.actions;
         diag._rule = obj.rule;
         diag._relatedInfo = obj.relatedInfo.map((info) => DiagnosticRelatedInfo.fromJsonObj(info));
+        diag._data = obj.data;
         return diag;
       }
       addAction(action) {
@@ -3227,6 +3235,12 @@ var require_diagnostic = __commonJS({
           this._actions.push(action);
         }
       }
+      setData(data) {
+        this._data = data;
+      }
+      getData() {
+        return this._data;
+      }
       getActions() {
         return this._actions;
       }
@@ -12564,7 +12578,7 @@ var require_cancellationUtils = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/common/cancellationUtils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.CancellationThrottle = exports2.FileBasedToken = exports2.DefaultCancellationProvider = exports2.OperationCanceledException = void 0;
+    exports2.CancellationThrottle = exports2.FileBasedToken = exports2.CancelledTokenId = exports2.DefaultCancellationProvider = exports2.OperationCanceledException = exports2.CancellationProvider = void 0;
     exports2.getCancellationFolderName = getCancellationFolderName;
     exports2.setCancellationFolderName = setCancellationFolderName;
     exports2.invalidateTypeCacheIfCanceled = invalidateTypeCacheIfCanceled;
@@ -12579,6 +12593,13 @@ var require_cancellationUtils = __commonJS({
     var vscode_languageserver_1 = require_api3();
     var core_1 = require_core();
     var uriUtils_1 = require_uriUtils();
+    var CancellationProvider;
+    (function(CancellationProvider2) {
+      function is(value) {
+        return value && !!value.createCancellationTokenSource;
+      }
+      CancellationProvider2.is = is;
+    })(CancellationProvider || (exports2.CancellationProvider = CancellationProvider = {}));
     var cancellationFolderName;
     function getCancellationFolderName() {
       return cancellationFolderName;
@@ -12654,7 +12675,11 @@ var require_cancellationUtils = __commonJS({
       }
     };
     exports2.DefaultCancellationProvider = DefaultCancellationProvider;
+    exports2.CancelledTokenId = "cancelled";
     function getCancellationTokenId(token) {
+      if (token === vscode_languageserver_1.CancellationToken.Cancelled) {
+        return exports2.CancelledTokenId;
+      }
       return token instanceof FileBasedToken ? token.id : void 0;
     }
     var FileBasedToken = class {
@@ -15052,63 +15077,127 @@ var require_programTypes = __commonJS({
   }
 });
 
-// node_modules/@zzzen/pyright-internal/dist/common/fileSystem.js
-var require_fileSystem = __commonJS({
-  "node_modules/@zzzen/pyright-internal/dist/common/fileSystem.js"(exports2) {
+// node_modules/@zzzen/pyright-internal/dist/analyzer/pyTypedUtils.js
+var require_pyTypedUtils = __commonJS({
+  "node_modules/@zzzen/pyright-internal/dist/analyzer/pyTypedUtils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.VirtualDirent = exports2.TempFile = exports2.FileSystem = void 0;
-    var FileSystem;
-    (function(FileSystem2) {
-      function is(value) {
-        return value.createFileSystemWatcher && value.createReadStream && value.createWriteStream && value.copyFileSync;
-      }
-      FileSystem2.is = is;
-    })(FileSystem || (exports2.FileSystem = FileSystem = {}));
-    var TempFile;
-    (function(TempFile2) {
-      function is(value) {
-        return value.tmpdir && value.tmpfile;
+    exports2.getPyTypedInfo = getPyTypedInfo;
+    exports2.getPyTypedInfoForPyTypedFile = getPyTypedInfoForPyTypedFile;
+    var uriUtils_1 = require_uriUtils();
+    function getPyTypedInfo(fileSystem, dirPath) {
+      if (!fileSystem.existsSync(dirPath) || !(0, uriUtils_1.isDirectory)(fileSystem, dirPath)) {
+        return void 0;
       }
-      TempFile2.is = is;
-    })(TempFile || (exports2.TempFile = TempFile = {}));
-    var VirtualDirent = class {
-      constructor(name, _file, parentPath) {
-        this.name = name;
-        this._file = _file;
-        this.parentPath = parentPath;
+      const pyTypedPath = dirPath.pytypedUri;
+      if (!fileSystem.existsSync(pyTypedPath) || !(0, uriUtils_1.isFile)(fileSystem, pyTypedPath)) {
+        return void 0;
       }
-      /**
-       * Alias for `dirent.parentPath`.
-       * @since v20.1.0
-       * @deprecated Since v20.12.0
-       */
-      get path() {
-        return this.parentPath;
+      return getPyTypedInfoForPyTypedFile(fileSystem, pyTypedPath);
+    }
+    function getPyTypedInfoForPyTypedFile(fileSystem, pyTypedPath) {
+      let isPartiallyTyped = false;
+      const fileStats = fileSystem.statSync(pyTypedPath);
+      if (fileStats.size > 0 && fileStats.size < 64 * 1024) {
+        const pyTypedContents = fileSystem.readFileSync(pyTypedPath, "utf8");
+        if (pyTypedContents.match(/partial\n/) || pyTypedContents.match(/partial\r\n/)) {
+          isPartiallyTyped = true;
+        }
       }
-      isFile() {
-        return this._file;
+      return {
+        pyTypedPath,
+        isPartiallyTyped
+      };
+    }
+  }
+});
+
+// node_modules/@zzzen/pyright-internal/dist/partialStubService.js
+var require_partialStubService = __commonJS({
+  "node_modules/@zzzen/pyright-internal/dist/partialStubService.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PartialStubService = exports2.SupportPartialStubs = void 0;
+    var pyTypedUtils_1 = require_pyTypedUtils();
+    var pathConsts_1 = require_pathConsts();
+    var uriUtils_1 = require_uriUtils();
+    var SupportPartialStubs;
+    (function(SupportPartialStubs2) {
+      function is(value) {
+        return value.isPartialStubPackagesScanned && value.isPathScanned && value.processPartialStubPackages && value.clearPartialStubs;
       }
-      isDirectory() {
-        return !this._file;
+      SupportPartialStubs2.is = is;
+    })(SupportPartialStubs || (exports2.SupportPartialStubs = SupportPartialStubs = {}));
+    var PartialStubService = class {
+      constructor(_realFs) {
+        this._realFs = _realFs;
+        this._rootSearched = /* @__PURE__ */ new Set();
+        this._partialStubPackagePaths = /* @__PURE__ */ new Set();
+        this._movedDirectories = [];
       }
-      isBlockDevice() {
-        return false;
+      isPartialStubPackagesScanned(execEnv) {
+        return execEnv.root ? this.isPathScanned(execEnv.root) : false;
       }
-      isCharacterDevice() {
-        return false;
+      isPathScanned(uri) {
+        return this._rootSearched.has(uri.key);
       }
-      isSymbolicLink() {
-        return false;
+      processPartialStubPackages(paths, roots, bundledStubPath, allowMoving) {
+        var _a;
+        const allowMovingFn = allowMoving ?? this._allowMoving.bind(this);
+        for (const path13 of paths) {
+          this._rootSearched.add(path13.key);
+          if (!this._realFs.existsSync(path13) || !(0, uriUtils_1.isDirectory)(this._realFs, path13)) {
+            continue;
+          }
+          let dirEntries = [];
+          try {
+            dirEntries = this._realFs.readdirEntriesSync(path13);
+          } catch {
+          }
+          const isBundledStub = path13.equals(bundledStubPath);
+          for (const entry of dirEntries) {
+            const partialStubPackagePath = path13.combinePaths(entry.name);
+            const isDirectory = !entry.isSymbolicLink() ? entry.isDirectory() : !!((_a = (0, uriUtils_1.tryStat)(this._realFs, partialStubPackagePath)) == null ? void 0 : _a.isDirectory());
+            if (!isDirectory || !entry.name.endsWith(pathConsts_1.stubsSuffix)) {
+              continue;
+            }
+            const pyTypedInfo = (0, pyTypedUtils_1.getPyTypedInfo)(this._realFs, partialStubPackagePath);
+            if (!pyTypedInfo || !pyTypedInfo.isPartiallyTyped) {
+              continue;
+            }
+            this._partialStubPackagePaths.add(partialStubPackagePath.key);
+            const packageName = entry.name.substr(0, entry.name.length - pathConsts_1.stubsSuffix.length);
+            for (const root of roots) {
+              const packagePath = root.combinePaths(packageName);
+              try {
+                const stat = (0, uriUtils_1.tryStat)(this._realFs, packagePath);
+                if (!(stat == null ? void 0 : stat.isDirectory())) {
+                  continue;
+                }
+                if (!allowMovingFn(isBundledStub, (0, pyTypedUtils_1.getPyTypedInfo)(this._realFs, packagePath), pyTypedInfo)) {
+                  continue;
+                }
+                this._movedDirectories.push(this._realFs.mapDirectory(packagePath, partialStubPackagePath, (u, fs8) => u.hasExtension(".pyi") || fs8.existsSync(u) && fs8.statSync(u).isDirectory()));
+              } catch {
+              }
+            }
+          }
+        }
       }
-      isFIFO() {
-        return false;
+      clearPartialStubs() {
+        this._rootSearched.clear();
+        this._partialStubPackagePaths.clear();
+        this._movedDirectories.forEach((d) => d.dispose());
+        this._movedDirectories = [];
       }
-      isSocket() {
-        return false;
+      _allowMoving(isBundled, packagePyTyped, _stubPyTyped) {
+        if (!isBundled) {
+          return true;
+        }
+        return !packagePyTyped || packagePyTyped.isPartiallyTyped;
       }
     };
-    exports2.VirtualDirent = VirtualDirent;
+    exports2.PartialStubService = PartialStubService;
   }
 });
 
@@ -15831,6 +15920,66 @@ var require_docStringService = __commonJS({
   }
 });
 
+// node_modules/@zzzen/pyright-internal/dist/common/fileSystem.js
+var require_fileSystem = __commonJS({
+  "node_modules/@zzzen/pyright-internal/dist/common/fileSystem.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.VirtualDirent = exports2.TempFile = exports2.FileSystem = void 0;
+    var FileSystem;
+    (function(FileSystem2) {
+      function is(value) {
+        return value.createFileSystemWatcher && value.createReadStream && value.createWriteStream && value.copyFileSync;
+      }
+      FileSystem2.is = is;
+    })(FileSystem || (exports2.FileSystem = FileSystem = {}));
+    var TempFile;
+    (function(TempFile2) {
+      function is(value) {
+        return value.tmpdir && value.tmpfile;
+      }
+      TempFile2.is = is;
+    })(TempFile || (exports2.TempFile = TempFile = {}));
+    var VirtualDirent = class {
+      constructor(name, _file, parentPath) {
+        this.name = name;
+        this._file = _file;
+        this.parentPath = parentPath;
+      }
+      /**
+       * Alias for `dirent.parentPath`.
+       * @since v20.1.0
+       * @deprecated Since v20.12.0
+       */
+      get path() {
+        return this.parentPath;
+      }
+      isFile() {
+        return this._file;
+      }
+      isDirectory() {
+        return !this._file;
+      }
+      isBlockDevice() {
+        return false;
+      }
+      isCharacterDevice() {
+        return false;
+      }
+      isSymbolicLink() {
+        return false;
+      }
+      isFIFO() {
+        return false;
+      }
+      isSocket() {
+        return false;
+      }
+    };
+    exports2.VirtualDirent = VirtualDirent;
+  }
+});
+
 // node_modules/@zzzen/pyright-internal/dist/common/languageServerInterface.js
 var require_languageServerInterface = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/common/languageServerInterface.js"(exports2) {
@@ -15861,158 +16010,6 @@ var require_languageServerInterface = __commonJS({
   }
 });
 
-// node_modules/@zzzen/pyright-internal/dist/analyzer/pyTypedUtils.js
-var require_pyTypedUtils = __commonJS({
-  "node_modules/@zzzen/pyright-internal/dist/analyzer/pyTypedUtils.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getPyTypedInfo = getPyTypedInfo;
-    exports2.getPyTypedInfoForPyTypedFile = getPyTypedInfoForPyTypedFile;
-    var uriUtils_1 = require_uriUtils();
-    function getPyTypedInfo(fileSystem, dirPath) {
-      if (!fileSystem.existsSync(dirPath) || !(0, uriUtils_1.isDirectory)(fileSystem, dirPath)) {
-        return void 0;
-      }
-      const pyTypedPath = dirPath.pytypedUri;
-      if (!fileSystem.existsSync(pyTypedPath) || !(0, uriUtils_1.isFile)(fileSystem, pyTypedPath)) {
-        return void 0;
-      }
-      return getPyTypedInfoForPyTypedFile(fileSystem, pyTypedPath);
-    }
-    function getPyTypedInfoForPyTypedFile(fileSystem, pyTypedPath) {
-      let isPartiallyTyped = false;
-      const fileStats = fileSystem.statSync(pyTypedPath);
-      if (fileStats.size > 0 && fileStats.size < 64 * 1024) {
-        const pyTypedContents = fileSystem.readFileSync(pyTypedPath, "utf8");
-        if (pyTypedContents.match(/partial\n/) || pyTypedContents.match(/partial\r\n/)) {
-          isPartiallyTyped = true;
-        }
-      }
-      return {
-        pyTypedPath,
-        isPartiallyTyped
-      };
-    }
-  }
-});
-
-// node_modules/@zzzen/pyright-internal/dist/partialStubService.js
-var require_partialStubService = __commonJS({
-  "node_modules/@zzzen/pyright-internal/dist/partialStubService.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.PartialStubService = exports2.SupportPartialStubs = void 0;
-    var pyTypedUtils_1 = require_pyTypedUtils();
-    var pathConsts_1 = require_pathConsts();
-    var uriUtils_1 = require_uriUtils();
-    var SupportPartialStubs;
-    (function(SupportPartialStubs2) {
-      function is(value) {
-        return value.isPartialStubPackagesScanned && value.isPathScanned && value.processPartialStubPackages && value.clearPartialStubs;
-      }
-      SupportPartialStubs2.is = is;
-    })(SupportPartialStubs || (exports2.SupportPartialStubs = SupportPartialStubs = {}));
-    var PartialStubService = class {
-      constructor(_realFs) {
-        this._realFs = _realFs;
-        this._rootSearched = /* @__PURE__ */ new Set();
-        this._partialStubPackagePaths = /* @__PURE__ */ new Set();
-        this._movedDirectories = [];
-      }
-      isPartialStubPackagesScanned(execEnv) {
-        return execEnv.root ? this.isPathScanned(execEnv.root) : false;
-      }
-      isPathScanned(uri) {
-        return this._rootSearched.has(uri.key);
-      }
-      processPartialStubPackages(paths, roots, bundledStubPath, allowMoving) {
-        var _a;
-        const allowMovingFn = allowMoving ?? this._allowMoving.bind(this);
-        for (const path13 of paths) {
-          this._rootSearched.add(path13.key);
-          if (!this._realFs.existsSync(path13) || !(0, uriUtils_1.isDirectory)(this._realFs, path13)) {
-            continue;
-          }
-          let dirEntries = [];
-          try {
-            dirEntries = this._realFs.readdirEntriesSync(path13);
-          } catch {
-          }
-          const isBundledStub = path13.equals(bundledStubPath);
-          for (const entry of dirEntries) {
-            const partialStubPackagePath = path13.combinePaths(entry.name);
-            const isDirectory = !entry.isSymbolicLink() ? entry.isDirectory() : !!((_a = (0, uriUtils_1.tryStat)(this._realFs, partialStubPackagePath)) == null ? void 0 : _a.isDirectory());
-            if (!isDirectory || !entry.name.endsWith(pathConsts_1.stubsSuffix)) {
-              continue;
-            }
-            const pyTypedInfo = (0, pyTypedUtils_1.getPyTypedInfo)(this._realFs, partialStubPackagePath);
-            if (!pyTypedInfo || !pyTypedInfo.isPartiallyTyped) {
-              continue;
-            }
-            this._partialStubPackagePaths.add(partialStubPackagePath.key);
-            const packageName = entry.name.substr(0, entry.name.length - pathConsts_1.stubsSuffix.length);
-            for (const root of roots) {
-              const packagePath = root.combinePaths(packageName);
-              try {
-                const stat = (0, uriUtils_1.tryStat)(this._realFs, packagePath);
-                if (!(stat == null ? void 0 : stat.isDirectory())) {
-                  continue;
-                }
-                if (!allowMovingFn(isBundledStub, (0, pyTypedUtils_1.getPyTypedInfo)(this._realFs, packagePath), pyTypedInfo)) {
-                  continue;
-                }
-                this._movedDirectories.push(this._realFs.mapDirectory(packagePath, partialStubPackagePath, (u, fs8) => u.hasExtension(".pyi") || fs8.existsSync(u) && fs8.statSync(u).isDirectory()));
-              } catch {
-              }
-            }
-          }
-        }
-      }
-      clearPartialStubs() {
-        this._rootSearched.clear();
-        this._partialStubPackagePaths.clear();
-        this._movedDirectories.forEach((d) => d.dispose());
-        this._movedDirectories = [];
-      }
-      _allowMoving(isBundled, packagePyTyped, _stubPyTyped) {
-        if (!isBundled) {
-          return true;
-        }
-        return !packagePyTyped || packagePyTyped.isPartiallyTyped;
-      }
-      _getRelativePathPartialStubs(partialStubPath) {
-        const relativePaths = [];
-        const searchAllStubs = (uri) => {
-          for (const entry of this._realFs.readdirEntriesSync(uri)) {
-            const filePath = uri.combinePaths(entry.name);
-            let isDirectory = entry.isDirectory();
-            let isFile = entry.isFile();
-            if (entry.isSymbolicLink()) {
-              const stat = (0, uriUtils_1.tryStat)(this._realFs, filePath);
-              if (stat) {
-                isDirectory = stat.isDirectory();
-                isFile = stat.isFile();
-              }
-            }
-            if (isDirectory) {
-              searchAllStubs(filePath);
-            }
-            if (isFile && entry.name.endsWith(".pyi")) {
-              const relative = partialStubPath.getRelativePathComponents(filePath).join("/");
-              if (relative) {
-                relativePaths.push(relative);
-              }
-            }
-          }
-        };
-        searchAllStubs(partialStubPath);
-        return relativePaths;
-      }
-    };
-    exports2.PartialStubService = PartialStubService;
-  }
-});
-
 // node_modules/@zzzen/pyright-internal/dist/common/serviceProviderExtensions.js
 var require_serviceProviderExtensions = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/common/serviceProviderExtensions.js"(exports2) {
@@ -16022,14 +16019,15 @@ var require_serviceProviderExtensions = __commonJS({
     var cacheManager_1 = require_cacheManager();
     var programTypes_1 = require_programTypes();
     var sourceFile_1 = require_sourceFile();
-    var serviceKeys_1 = require_serviceKeys();
+    var partialStubService_1 = require_partialStubService();
+    var cancellationUtils_1 = require_cancellationUtils();
     var caseSensitivityDetector_1 = require_caseSensitivityDetector();
     var console_1 = require_console();
-    var fileSystem_1 = require_fileSystem();
-    var serviceProvider_1 = require_serviceProvider();
     var docStringService_1 = require_docStringService();
+    var fileSystem_1 = require_fileSystem();
     var languageServerInterface_1 = require_languageServerInterface();
-    var partialStubService_1 = require_partialStubService();
+    var serviceKeys_1 = require_serviceKeys();
+    var serviceProvider_1 = require_serviceProvider();
     function createServiceProvider(...services2) {
       const sp = new serviceProvider_1.ServiceProvider();
       services2.forEach((service) => {
@@ -16063,6 +16061,9 @@ var require_serviceProviderExtensions = __commonJS({
         if (languageServerInterface_1.CommandService.is(service)) {
           sp.add(serviceKeys_1.ServiceKeys.commandService, service);
         }
+        if (cancellationUtils_1.CancellationProvider.is(service)) {
+          sp.add(serviceKeys_1.ServiceKeys.cancellationProvider, service);
+        }
       });
       return sp;
     }
@@ -16073,11 +16074,18 @@ var require_serviceProviderExtensions = __commonJS({
       return this.get(serviceKeys_1.ServiceKeys.console);
     };
     serviceProvider_1.ServiceProvider.prototype.partialStubs = function() {
+      const result = this.tryGet(serviceKeys_1.ServiceKeys.partialStubs);
+      if (!result) {
+        this.add(serviceKeys_1.ServiceKeys.partialStubs, new partialStubService_1.PartialStubService(this.fs()));
+      }
       return this.get(serviceKeys_1.ServiceKeys.partialStubs);
     };
     serviceProvider_1.ServiceProvider.prototype.tmp = function() {
       return this.tryGet(serviceKeys_1.ServiceKeys.tempFile);
     };
+    serviceProvider_1.ServiceProvider.prototype.cancellationProvider = function() {
+      return this.tryGet(serviceKeys_1.ServiceKeys.cancellationProvider) ?? new cancellationUtils_1.DefaultCancellationProvider();
+    };
     serviceProvider_1.ServiceProvider.prototype.sourceFileFactory = function() {
       const result = this.tryGet(serviceKeys_1.ServiceKeys.sourceFileFactory);
       return result || DefaultSourceFileFactory;
@@ -16291,6 +16299,7 @@ var require_package_nls_cs = __commonJS({
         baseClassUnknown: "Typ z\xE1kladn\xED t\u0159\xEDdy je nezn\xE1m\xFD, co zakr\xFDv\xE1 typ odvozen\xE9 t\u0159\xEDdy",
         baseClassVariableTypeIncompatible: "Z\xE1kladn\xED t\u0159\xEDdy pro t\u0159\xEDdu {classType} definuj\xED prom\u011Bnnou {name} nekompatibiln\xEDm zp\u016Fsobem",
         binaryOperationNotAllowed: "Ve v\xFDrazu typu nen\xED povolen\xFD bin\xE1rn\xED oper\xE1tor.",
+        bindParamMissing: "Nepovedlo se vytvo\u0159it vazbu metody {methodName}, proto\u017Ee chyb\xED parametr self nebo cls",
         bindTypeMismatch: "Nepovedlo se vytvo\u0159it vazbu metody \u201E{methodName}\u201C, proto\u017Ee \u201E{type}\u201C nejde p\u0159i\u0159adit k parametru \u201E{paramName}\u201C",
         breakInExceptionGroup: "V bloku except* nen\xED povolen\xE1 mo\u017Enost break.",
         breakOutsideLoop: "\u201Ebreak\u201C se d\xE1 pou\u017E\xEDt jenom ve smy\u010Dce",
@@ -16722,6 +16731,7 @@ var require_package_nls_cs = __commonJS({
         typeAliasRedeclared: "\u201E{name}\u201C se deklaruje jako TypeAlias a d\xE1 se p\u0159i\u0159adit jenom jednou.",
         typeAliasStatementBadScope: "P\u0159\xEDkaz type se d\xE1 pou\u017E\xEDt jenom v r\xE1mci oboru modulu nebo t\u0159\xEDdy.",
         typeAliasStatementIllegal: "P\u0159\xEDkaz alias typu vy\u017Eaduje Python 3.12 nebo nov\u011Bj\u0161\xED",
+        typeAliasTypeBadScope: "Alias typu se d\xE1 definovat jenom v r\xE1mci oboru modulu nebo t\u0159\xEDdy",
         typeAliasTypeBaseClass: 'Alias typu definovan\xFD v p\u0159\xEDkazu "type" nejde pou\u017E\xEDt jako z\xE1kladn\xED t\u0159\xEDdu.',
         typeAliasTypeMustBeAssigned: "Typ TypeAliasType mus\xED b\xFDt p\u0159i\u0159azen prom\u011Bnn\xE9 se stejn\xFDm n\xE1zvem jako alias typu",
         typeAliasTypeNameArg: "Prvn\xED argument TypeAliasType mus\xED b\xFDt \u0159et\u011Bzcov\xFD liter\xE1l p\u0159edstavuj\xEDc\xED n\xE1zev aliasu typu.",
@@ -16933,6 +16943,7 @@ var require_package_nls_cs = __commonJS({
         kwargsParamMissing: "Parametr \u201E**{paramName}\u201C nem\xE1 \u017E\xE1dn\xFD odpov\xEDdaj\xEDc\xED parametr",
         listAssignmentMismatch: "Typ {type} nen\xED kompatibiln\xED s c\xEDlov\xFDm seznamem",
         literalAssignmentMismatch: "{sourceType} se ned\xE1 p\u0159i\u0159adit k typu {destType}.",
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: "Pokud nen\xED zam\xFD\u0161leno vy\u010Derp\xE1vaj\xEDc\xED zpracov\xE1n\xED, p\u0159idejte case _: pass",
         matchIsNotExhaustiveType: "Nezpracovan\xFD typ: {type}",
         memberAssignment: "V\xFDraz typu {type} nelze p\u0159i\u0159adit k atributu {name} t\u0159\xEDdy {classType}.",
@@ -17130,6 +17141,7 @@ var require_package_nls_de = __commonJS({
         baseClassUnknown: "Der Basisklassentyp ist unbekannt, sodass der Typ der abgeleiteten Klasse verdeckt wird.",
         baseClassVariableTypeIncompatible: 'Basisklassen f\xFCr die Klasse "{classType}" definieren die Variable "{name}" auf inkompatible Weise.',
         binaryOperationNotAllowed: "Der bin\xE4rer Operator ist im Typausdruck nicht zul\xE4ssig",
+        bindParamMissing: "Die Methode \u201E{methodName}\u201C konnte nicht gebunden werden, weil der Parameter \u201Eself\u201C oder \u201Ecls\u201C fehlt.",
         bindTypeMismatch: 'Die Methode "{methodName}" konnte nicht gebunden werden, da "{type}" dem Parameter "{paramName}" nicht zugewiesen werden kann.',
         breakInExceptionGroup: "\u201Ebreak\u201C ist in einem \u201Eexcept*\u201C Block nicht zul\xE4ssig.",
         breakOutsideLoop: '"break" kann nur innerhalb einer Schleife verwendet werden.',
@@ -17561,6 +17573,7 @@ var require_package_nls_de = __commonJS({
         typeAliasRedeclared: '"{name}" ist als TypeAlias deklariert und kann nur einmal zugewiesen werden.',
         typeAliasStatementBadScope: "Eine type Anweisung kann nur innerhalb eines Moduls oder Klassenbereichs verwendet werden.",
         typeAliasStatementIllegal: "Die Typaliasanweisung erfordert Python 3.12 oder h\xF6her.",
+        typeAliasTypeBadScope: "Ein Typalias kann nur innerhalb eines Modul- oder Klassenbereichs definiert werden.",
         typeAliasTypeBaseClass: 'Ein in einer "type"-Anweisung definierter type Alias kann nicht als Basisklasse verwendet werden.',
         typeAliasTypeMustBeAssigned: "TypeAliasType muss einer Variablen mit dem gleichen Namen wie der Typalias zugewiesen werden.",
         typeAliasTypeNameArg: "Das erste Argument f\xFCr TypeAliasType muss ein Zeichenfolgenliteral sein, das den Namen des Typalias darstellt.",
@@ -17656,11 +17669,11 @@ var require_package_nls_de = __commonJS({
         typedDictSecondArgDict: "Es wird ein dict- oder Schl\xFCsselwortparameter als zweiter Parameter erwartet.",
         typedDictSecondArgDictEntry: "Einfacher W\xF6rterbucheintrag erwartet",
         typedDictSet: "Element konnte in TypedDict nicht zugewiesen werden.",
-        unaccessedClass: 'Auf die Klasse "{name}" kann nicht zugegriffen werden.',
-        unaccessedFunction: 'Auf die Funktion "{name}" kann nicht zugegriffen werden.',
-        unaccessedImport: 'Auf den Import "{name}" kann nicht zugegriffen werden.',
-        unaccessedSymbol: 'Auf "{name}" kann nicht zugegriffen werden.',
-        unaccessedVariable: 'Auf die Variable "{name}" kann nicht zugegriffen werden.',
+        unaccessedClass: 'Auf Klasse "{name}" wird nicht zugegriffen',
+        unaccessedFunction: 'Auf Funktion "{name}" wird nicht zugegriffen',
+        unaccessedImport: 'Auf Import "{name}" wird nicht zugegriffen',
+        unaccessedSymbol: 'Auf "{name}" wird nicht zugegriffen',
+        unaccessedVariable: 'Auf Variable "{name}" wird nicht zugegriffen',
         unannotatedFunctionSkipped: 'Die Analyse der Funktion "{name}" wird \xFCbersprungen, da sie nicht kommentiert wurde.',
         unaryOperationNotAllowed: "Der un\xE4re Operator ist im Typausdruck nicht zul\xE4ssig",
         unexpectedAsyncToken: 'Es wurde erwartet, dass "def", "with" oder "for" auf "async" folgt.',
@@ -17772,6 +17785,7 @@ var require_package_nls_de = __commonJS({
         kwargsParamMissing: 'Der Parameter "**{paramName}" weist keinen entsprechenden Parameter auf.',
         listAssignmentMismatch: 'Der Typ "{type}" ist nicht mit der Zielliste kompatibel.',
         literalAssignmentMismatch: "\u201E{sourceType}\u201C kann dem Typ \u201E{destType}\u201C nicht zugewiesen werden.",
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: 'Wenn keine ausf\xFChrliche Behandlung beabsichtigt ist, f\xFCgen Sie "case _: pass" hinzu.',
         matchIsNotExhaustiveType: 'Unbehandelter Typ: "{type}"',
         memberAssignment: "Ein Ausdruck vom Typ \u201E{type}\u201C kann dem Attribut \u201E{name}\u201C der Klasse \u201E{classType}\u201C nicht zugewiesen werden",
@@ -18395,6 +18409,18 @@ var require_package_nls_en_us = __commonJS({
           message: 'A "Final" variable cannot be assigned within a loop',
           comment: "{Locked='Final'}"
         },
+        finallyBreak: {
+          message: 'A "break" cannot be used to exit a "finally" block',
+          comment: "{Locked='break', 'finally'}"
+        },
+        finallyContinue: {
+          message: 'A "continue" cannot be used to exit a "finally" block',
+          comment: "{Locked='continue', 'finally'}"
+        },
+        finallyReturn: {
+          message: 'A "return" cannot be used to exit a "finally" block',
+          comment: "{Locked='return', 'finally'}"
+        },
         finalMethodOverride: {
           message: 'Method "{name}" cannot override final method defined in class "{className}"',
           comment: "{Locked='final'}"
@@ -18672,6 +18698,10 @@ var require_package_nls_en_us = __commonJS({
           message: 'Cannot override "{name}" because parent class "{className}" is a named tuple',
           comment: "{Locked='tuple'}"
         },
+        namedTupleFieldUnderscore: {
+          message: "Named tuple field names cannot start with an underscore",
+          comment: "{Locked='Named','tuple'}"
+        },
         namedTupleFirstArg: {
           message: "Expected named tuple class name as first argument",
           comment: "{Locked='tuple'}"
@@ -18691,7 +18721,7 @@ var require_package_nls_en_us = __commonJS({
         },
         namedTupleNoTypes: {
           message: '"namedtuple" provides no types for tuple entries; use "NamedTuple" instead',
-          comment: `{Locked='namedtuple";'tuple','NamedTuple'}`
+          comment: "{Locked='namedtuple','tuple','NamedTuple'}"
         },
         namedTupleSecondArg: {
           message: "Expected named tuple entry list as second argument",
@@ -19753,6 +19783,10 @@ var require_package_nls_en_us = __commonJS({
         kwargsParamMissing: 'Parameter "**{paramName}" has no corresponding parameter',
         listAssignmentMismatch: 'Type "{type}" is incompatible with target list',
         literalAssignmentMismatch: '"{sourceType}" is not assignable to type "{destType}"',
+        literalNotAllowed: {
+          message: '"Literal" special form cannot be used with instance and class checks',
+          comment: "{Locked='Literal'}"
+        },
         matchIsNotExhaustiveHint: {
           message: 'If exhaustive handling is not intended, add "case _: pass"',
           comment: "{Locked='case _: pass'}"
@@ -20085,6 +20119,7 @@ var require_package_nls_es = __commonJS({
         baseClassUnknown: "Se desconoce el tipo de la clase base, lo que oculta el tipo de la clase derivada.",
         baseClassVariableTypeIncompatible: 'Las clases base para la clase "{classType}" definen la variable "{name}" de forma incompatible',
         binaryOperationNotAllowed: "Operador binario no permitido en la expresi\xF3n de tipo",
+        bindParamMissing: 'No se pudo enlazar el m\xE9todo "{methodName}" porque falta un par\xE1metro "self" o "cls"',
         bindTypeMismatch: 'No se pudo enlazar el m\xE9todo "{methodName}" porque "{type}" no se puede asignar al par\xE1metro "{paramName}"',
         breakInExceptionGroup: 'No se permite "break" en un bloque "except*"',
         breakOutsideLoop: '"break" solo se puede usar dentro de un bucle',
@@ -20516,6 +20551,7 @@ var require_package_nls_es = __commonJS({
         typeAliasRedeclared: '"{name}" se declara como TypeAlias y solo puede asignarse una vez',
         typeAliasStatementBadScope: "Una instrucci\xF3n de type solo se puede usar en el \xE1mbito de un m\xF3dulo o de una clase",
         typeAliasStatementIllegal: "La sentencia Type alias requiere Python 3.12 o posterior",
+        typeAliasTypeBadScope: "Un alias de tipo solo se puede definir dentro de un \xE1mbito de m\xF3dulo o clase",
         typeAliasTypeBaseClass: 'Un alias de tipo definido en una instrucci\xF3n "type" no se puede usar como clase base',
         typeAliasTypeMustBeAssigned: "TypeAliasType debe asignarse a una variable con el mismo nombre que el alias de tipo",
         typeAliasTypeNameArg: "El primer argumento de TypeAliasType debe ser un literal de cadena que represente el nombre del alias de tipo",
@@ -20727,6 +20763,7 @@ var require_package_nls_es = __commonJS({
         kwargsParamMissing: 'El par\xE1metro "**{paramName}" no tiene ning\xFAn par\xE1metro correspondiente.',
         listAssignmentMismatch: 'El tipo "{type}" es incompatible con la lista de objetivos',
         literalAssignmentMismatch: '"{sourceType}" no se puede asignar al tipo "{destType}"',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: 'Si no se pretende un tratamiento exhaustivo, agregue "case _: pass"',
         matchIsNotExhaustiveType: 'Tipo no manejado: "{type}"',
         memberAssignment: 'La expresi\xF3n de tipo "{type}" no se puede asignar al atributo "{name}" de la clase "{classType}"',
@@ -20924,6 +20961,7 @@ var require_package_nls_fr = __commonJS({
         baseClassUnknown: "Le type de classe de base est inconnu, ce qui masque le type de classe d\xE9riv\xE9e",
         baseClassVariableTypeIncompatible: "Les classes de base de la classe \xAB\xA0{classType}\xA0\xBB d\xE9finissent la variable \xAB\xA0{name}\xA0\xBB de mani\xE8re incompatible",
         binaryOperationNotAllowed: "Op\xE9rateur binaire non autoris\xE9 dans l'expression de type",
+        bindParamMissing: "Impossible de lier la m\xE9thode \xAB\xA0{methodName}\xA0\xBB, car il manque un param\xE8tre \xAB\xA0self\xA0\xBB ou \xAB\xA0cls\xA0\xBB",
         bindTypeMismatch: `Impossible de lier la m\xE9thode "{methodName}" car "{type}" n'est pas attribuable au param\xE8tre "{paramName}"`,
         breakInExceptionGroup: "\xAB\xA0break\xA0\xBB n\u2019est pas autoris\xE9 dans un bloc \xAB\xA0except*\xA0\xBB",
         breakOutsideLoop: `"break" ne peut \xEAtre utilis\xE9 qu'\xE0 l'int\xE9rieur d'une boucle`,
@@ -21355,6 +21393,7 @@ var require_package_nls_fr = __commonJS({
         typeAliasRedeclared: "\xAB {name} \xBB est d\xE9clar\xE9 en tant que TypeAlias et ne peut \xEAtre attribu\xE9 qu\u2019une seule fois",
         typeAliasStatementBadScope: "Une instruction de type ne peut \xEAtre utilis\xE9e que dans une \xE9tendue de module ou de classe",
         typeAliasStatementIllegal: "L\u2019instruction d\u2019alias de type n\xE9cessite Python 3.12 ou version ult\xE9rieure",
+        typeAliasTypeBadScope: "Vous ne pouvez d\xE9finir un alias de type qu\u2019au sein d\u2019un module ou d\u2019une \xE9tendue de classe",
         typeAliasTypeBaseClass: 'A type alias defined in a "type" statement cannot be used as a base class',
         typeAliasTypeMustBeAssigned: "TypeAliasType doit \xEAtre affect\xE9 \xE0 une variable portant le m\xEAme nom que l'alias de type",
         typeAliasTypeNameArg: "Le premier argument de TypeAliasType doit \xEAtre un litt\xE9ral de cha\xEEne repr\xE9sentant le nom de l'alias de type",
@@ -21566,6 +21605,7 @@ var require_package_nls_fr = __commonJS({
         kwargsParamMissing: `Le param\xE8tre "**{paramName}" n'a pas de param\xE8tre correspondant`,
         listAssignmentMismatch: "Le type \xAB\xA0{type}\xA0\xBB n\u2019est pas compatible avec la liste cible",
         literalAssignmentMismatch: "\xAB\xA0{sourceType}\xA0\xBB n\u2019est pas assignable au type \xAB\xA0{destType}\xA0\xBB",
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: "Si la gestion exhaustive n\u2019est pas pr\xE9vue, ajoutez \xAB case _: pass \xBB",
         matchIsNotExhaustiveType: "Type non g\xE9r\xE9 : \xAB\xA0{type}\xA0\xBB",
         memberAssignment: "L'expression de type \xAB\xA0{type}\xA0\xBB ne peut pas \xEAtre attribu\xE9e \xE0 l\u2019attribut \xAB\xA0{name}\xA0\xBB de la classe \xAB\xA0{classType}\xA0\xBB",
@@ -21763,6 +21803,7 @@ var require_package_nls_it = __commonJS({
         baseClassUnknown: "Il tipo della classe di base \xE8 sconosciuto. \xC8 in corso il tentativo di determinare il tipo della classe derivata",
         baseClassVariableTypeIncompatible: 'Le classi di base per la classe "{classType}" definiscono la variabile "{name}" in modo incompatibile',
         binaryOperationNotAllowed: "Operatore binario non consentito nell'espressione di tipo",
+        bindParamMissing: 'Impossibile associare il metodo "{methodName}" dal momento che il parametro "self" o "cls" risulta mancante',
         bindTypeMismatch: 'Non \xE8 stato possibile associare il metodo "{methodName}" perch\xE9 non \xE8 possibile assegnare"{type}" al parametro "{paramName}"',
         breakInExceptionGroup: '"break" non consentito in un blocco "except*"',
         breakOutsideLoop: `"break" pu\xF2 essere usato solo all'interno di un ciclo`,
@@ -22194,6 +22235,7 @@ var require_package_nls_it = __commonJS({
         typeAliasRedeclared: '"{name}" \xE8 dichiarato come TypeAlias e pu\xF2 essere assegnato una sola volta',
         typeAliasStatementBadScope: "Un'istruzione type pu\xF2 essere usata solo all'interno di un modulo o di un ambito della classe",
         typeAliasStatementIllegal: "L'istruzione alias di tipo richiede Python 3.12 o versione successiva",
+        typeAliasTypeBadScope: "\xC8 possibile definire un alias di tipo solo all'interno di un ambito classe o modulo",
         typeAliasTypeBaseClass: `Impossibile utilizzare come classe di base un alias di tipo definito in un'istruzione "type"`,
         typeAliasTypeMustBeAssigned: "TypeAliasType deve essere assegnato a una variabile con lo stesso nome dell'alias di tipo",
         typeAliasTypeNameArg: "Il primo argomento di TypeAliasType deve essere un valore letterale stringa che rappresenta il nome dell'alias di tipo",
@@ -22405,6 +22447,7 @@ var require_package_nls_it = __commonJS({
         kwargsParamMissing: 'Il parametro "**{paramName}" non ha un parametro corrispondente',
         listAssignmentMismatch: `Il tipo "{type}" non \xE8 compatibile con l'elenco di destinazione`,
         literalAssignmentMismatch: '"{sourceType}" non \xE8 assegnabile al tipo "{destType}"',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: 'Se la gestione completa non \xE8 prevista, aggiungere "case _: pass"',
         matchIsNotExhaustiveType: 'Tipo non gestito: "{type}"',
         memberAssignment: `L'espressione di tipo "{type}" non pu\xF2 essere assegnata all'attributo "{name}" della classe "{classType}".`,
@@ -22602,6 +22645,7 @@ var require_package_nls_ja = __commonJS({
         baseClassUnknown: "\u57FA\u5E95\u30AF\u30E9\u30B9\u306E\u578B\u304C\u4E0D\u660E\u3067\u3001\u6D3E\u751F\u30AF\u30E9\u30B9\u306E\u578B\u304C\u4E0D\u660E\u3067\u3059",
         baseClassVariableTypeIncompatible: '\u30AF\u30E9\u30B9 "{classType}" \u306E\u57FA\u5E95\u30AF\u30E9\u30B9\u306F\u3001\u4E92\u63DB\u6027\u306E\u306A\u3044\u65B9\u6CD5\u3067\u5909\u6570 "{name}" \u3092\u5B9A\u7FA9\u3057\u307E\u3059',
         binaryOperationNotAllowed: "2 \u9805\u6F14\u7B97\u5B50\u306F\u578B\u5F0F\u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093",
+        bindParamMissing: '"self" \u307E\u305F\u306F "cls" \u30D1\u30E9\u30E1\u30FC\u30BF\u30FC\u304C\u306A\u3044\u305F\u3081\u3001\u30E1\u30BD\u30C3\u30C9 "{methodName}" \u3092\u30D0\u30A4\u30F3\u30C9\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F',
         bindTypeMismatch: '"{type}" \u304C\u30D1\u30E9\u30E1\u30FC\u30BF\u30FC "{paramName}" \u306B\u5272\u308A\u5F53\u3066\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u30E1\u30BD\u30C3\u30C9 "{methodName}" \u3092\u30D0\u30A4\u30F3\u30C9\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F',
         breakInExceptionGroup: '"except*" \u30D6\u30ED\u30C3\u30AF\u3067\u306F "break" \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093',
         breakOutsideLoop: '"break" \u306F\u30EB\u30FC\u30D7\u5185\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059',
@@ -23033,6 +23077,7 @@ var require_package_nls_ja = __commonJS({
         typeAliasRedeclared: '"{name}" \u306F TypeAlias \u3068\u3057\u3066\u5BA3\u8A00\u3055\u308C\u3066\u304A\u308A\u30011 \u56DE\u3060\u3051\u5272\u308A\u5F53\u3066\u308B\u3053\u3068\u304C\u3067\u304D\u307E\u3059',
         typeAliasStatementBadScope: "type \u30B9\u30C6\u30FC\u30C8\u30E1\u30F3\u30C8\u306F\u3001\u30E2\u30B8\u30E5\u30FC\u30EB\u307E\u305F\u306F\u30AF\u30E9\u30B9\u30B9\u30B3\u30FC\u30D7\u5185\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059",
         typeAliasStatementIllegal: "\u578B\u30A8\u30A4\u30EA\u30A2\u30B9 \u30B9\u30C6\u30FC\u30C8\u30E1\u30F3\u30C8\u306B\u306F Python 3.12 \u4EE5\u964D\u304C\u5FC5\u8981\u3067\u3059",
+        typeAliasTypeBadScope: "\u578B\u30A8\u30A4\u30EA\u30A2\u30B9\u306F\u3001\u30E2\u30B8\u30E5\u30FC\u30EB\u307E\u305F\u306F\u30AF\u30E9\u30B9 \u30B9\u30B3\u30FC\u30D7\u5185\u3067\u306E\u307F\u5B9A\u7FA9\u3067\u304D\u307E\u3059",
         typeAliasTypeBaseClass: '"type" \u30B9\u30C6\u30FC\u30C8\u30E1\u30F3\u30C8\u3067\u5B9A\u7FA9\u3055\u308C\u305F\u578B\u30A8\u30A4\u30EA\u30A2\u30B9\u3092\u57FA\u5E95\u30AF\u30E9\u30B9\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',
         typeAliasTypeMustBeAssigned: "TypeAliasType \u306F\u3001\u578B\u30A8\u30A4\u30EA\u30A2\u30B9\u3068\u540C\u3058\u540D\u524D\u306E\u5909\u6570\u306B\u5272\u308A\u5F53\u3066\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
         typeAliasTypeNameArg: "TypeAliasType \u306E\u6700\u521D\u306E\u5F15\u6570\u306F\u3001\u578B\u30A8\u30A4\u30EA\u30A2\u30B9\u306E\u540D\u524D\u3092\u8868\u3059\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
@@ -23244,6 +23289,7 @@ var require_package_nls_ja = __commonJS({
         kwargsParamMissing: '\u30D1\u30E9\u30E1\u30FC\u30BF\u30FC "**{paramName}" \u306B\u5BFE\u5FDC\u3059\u308B\u30D1\u30E9\u30E1\u30FC\u30BF\u30FC\u304C\u3042\u308A\u307E\u305B\u3093',
         listAssignmentMismatch: '\u578B "{type}" \u306F\u30BF\u30FC\u30B2\u30C3\u30C8 \u30EA\u30B9\u30C8\u3068\u4E92\u63DB\u6027\u304C\u3042\u308A\u307E\u305B\u3093',
         literalAssignmentMismatch: '"{sourceType}" \u306F\u578B "{destType}" \u306B\u5272\u308A\u5F53\u3066\u3067\u304D\u307E\u305B\u3093',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: '\u5B8C\u5168\u306A\u51E6\u7406\u304C\u610F\u56F3\u3055\u308C\u3066\u3044\u306A\u3044\u5834\u5408\u306F\u3001"case _: pass" \u3092\u8FFD\u52A0\u3057\u307E\u3059',
         matchIsNotExhaustiveType: '\u30CF\u30F3\u30C9\u30EB\u3055\u308C\u306A\u3044\u578B: "{type}"',
         memberAssignment: '\u578B "{type}" \u306E\u5F0F\u3092\u30AF\u30E9\u30B9 "{classType}" \u306E\u5C5E\u6027 "{name}" \u306B\u5272\u308A\u5F53\u3066\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',
@@ -23441,6 +23487,7 @@ var require_package_nls_ko = __commonJS({
         baseClassUnknown: "\uAE30\uBCF8 \uD074\uB798\uC2A4 \uD615\uC2DD\uC744 \uC54C \uC218 \uC5C6\uC73C\uBBC0\uB85C \uD30C\uC0DD \uD074\uB798\uC2A4\uC758 \uD615\uC2DD\uC774 \uBAA8\uD638\uD569\uB2C8\uB2E4.",
         baseClassVariableTypeIncompatible: '"{classType}" \uD074\uB798\uC2A4\uC758 \uAE30\uBCF8 \uD074\uB798\uC2A4\uAC00 "{name}" \uBCC0\uC218\uB97C \uD638\uD658\uB418\uC9C0 \uC54A\uB294 \uBC29\uC2DD\uC73C\uB85C \uC815\uC758\uD569\uB2C8\uB2E4.',
         binaryOperationNotAllowed: "\uD615\uC2DD \uC2DD\uC5D0\uB294 \uC774\uD56D \uC5F0\uC0B0\uC790\uB97C \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
+        bindParamMissing: '"self" \uB610\uB294 "cls" \uB9E4\uAC1C \uBCC0\uC218\uAC00 \uB204\uB77D\uB418\uC5C8\uAE30 \uB54C\uBB38\uC5D0 \uBA54\uC11C\uB4DC "{methodName}"\uC744(\uB97C) \uBC14\uC778\uB529\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         bindTypeMismatch: "\u2018{type}\u2019\uC744(\uB97C) \uB9E4\uAC1C \uBCC0\uC218 \u2018{paramName}\u2019\uC5D0 \uD560\uB2F9\uD560 \uC218 \uC5C6\uC73C\uBBC0\uB85C \u2018{methodName}\u2019 \uBA54\uC11C\uB4DC\uB97C \uBC14\uC778\uB529\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
         breakInExceptionGroup: '"except*" \uBE14\uB85D\uC5D0\uB294 "break"\uB97C \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4',
         breakOutsideLoop: "\u2018break\u2019\uB294 \uB8E8\uD504 \uB0B4\uC5D0\uC11C\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
@@ -23872,6 +23919,7 @@ var require_package_nls_ko = __commonJS({
         typeAliasRedeclared: '"{name}"\uC740(\uB294) TypeAlias\uB85C \uC120\uC5B8\uB418\uBA70 \uD55C \uBC88\uB9CC \uD560\uB2F9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.',
         typeAliasStatementBadScope: "type \uBB38\uC740 \uBAA8\uB4C8 \uB610\uB294 \uD074\uB798\uC2A4 \uBC94\uC704 \uB0B4\uC5D0\uC11C\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
         typeAliasStatementIllegal: "\uD615\uC2DD \uBCC4\uCE6D \uBB38\uC5D0\uB294 Python 3.12 \uC774\uC0C1\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.",
+        typeAliasTypeBadScope: "\uD615\uC2DD \uBCC4\uCE6D\uC740 \uBAA8\uB4C8 \uB610\uB294 \uD074\uB798\uC2A4 \uBC94\uC704 \uB0B4\uC5D0\uC11C\uB9CC \uC815\uC758\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
         typeAliasTypeBaseClass: '"type" \uBB38\uC5D0 \uC815\uC758\uB41C \uD615\uC2DD \uBCC4\uCE6D\uC740 \uAE30\uBCF8 \uD074\uB798\uC2A4\uB85C \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         typeAliasTypeMustBeAssigned: "TypeAliasType\uC740 \uD615\uC2DD \uBCC4\uCE6D\uACFC \uC774\uB984\uC774 \uAC19\uC740 \uBCC0\uC218\uC5D0 \uD560\uB2F9\uD574\uC57C \uD569\uB2C8\uB2E4.",
         typeAliasTypeNameArg: "TypeAliasType\uC758 \uCCAB \uBC88\uC9F8 \uC778\uC218\uB294 \uD615\uC2DD \uBCC4\uCE6D\uC758 \uC774\uB984\uC744 \uB098\uD0C0\uB0B4\uB294 \uBB38\uC790\uC5F4 \uB9AC\uD130\uB7F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.",
@@ -24083,6 +24131,7 @@ var require_package_nls_ko = __commonJS({
         kwargsParamMissing: "\u2018**{paramName}\u2019 \uB9E4\uAC1C \uBCC0\uC218\uC5D0 \uD574\uB2F9\uD558\uB294 \uB9E4\uAC1C \uBCC0\uC218\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.",
         listAssignmentMismatch: '"{type}" \uD615\uC2DD\uC774 \uB300\uC0C1 \uBAA9\uB85D\uACFC \uD638\uD658\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.',
         literalAssignmentMismatch: '"{sourceType}"\uC740 \uD615\uC2DD "{destType}"\uC5D0 \uD560\uB2F9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: '\uC804\uCCB4 \uCC98\uB9AC\uAC00 \uC758\uB3C4\uB418\uC9C0 \uC54A\uC740 \uACBD\uC6B0 "case _: pass"\uB97C \uCD94\uAC00\uD569\uB2C8\uB2E4.',
         matchIsNotExhaustiveType: '\uCC98\uB9AC\uB418\uC9C0 \uC54A\uC740 \uD615\uC2DD: "{type}"',
         memberAssignment: '"{type}" \uD615\uC2DD\uC758 \uC2DD\uC744 "{classType}" \uD074\uB798\uC2A4\uC758 "{name}" \uD2B9\uC131\uC5D0 \uD560\uB2F9\uD560 \uC218 \uC5C6\uC74C',
@@ -24280,6 +24329,7 @@ var require_package_nls_pl = __commonJS({
         baseClassUnknown: "Typ klasy bazowej jest nieznany, zas\u0142aniaj\u0105c typ klasy pochodnej",
         baseClassVariableTypeIncompatible: "Klasy bazowe dla klasy \u201E{classType}\u201D definiuj\u0105 zmienn\u0105 \u201E{name}\u201D w niezgodny spos\xF3b",
         binaryOperationNotAllowed: "Operator binarny nie jest dozwolony w wyra\u017Ceniu typu",
+        bindParamMissing: "Nie mo\u017Cna powi\u0105za\u0107 metody \u201E{methodName}\u201D, poniewa\u017C brakuje w niej parametru \u201Eself\u201D lub \u201Ecls\u201D",
         bindTypeMismatch: "Nie mo\u017Cna powi\u0105za\u0107 metody \u201E{methodName}\u201D, poniewa\u017C nie mo\u017Cna przypisa\u0107 typu \u201E{type}\u201D do parametru \u201E{paramName}\u201D",
         breakInExceptionGroup: "\u201Ebreak\u201D nie jest dozwolone w bloku \u201Eexcept*\u201D",
         breakOutsideLoop: "Warto\u015B\u0107 \u201Ebreak\u201D mo\u017Ce by\u0107 u\u017Cywana tylko w p\u0119tli",
@@ -24711,6 +24761,7 @@ var require_package_nls_pl = __commonJS({
         typeAliasRedeclared: "Nazwa \u201E{name}\u201D jest zadeklarowana jako TypeAlias i mo\u017Ce by\u0107 przypisana tylko raz",
         typeAliasStatementBadScope: "Instrukcja type mo\u017Ce by\u0107 u\u017Cyta tylko w zakresie modu\u0142u lub klasy",
         typeAliasStatementIllegal: "Instrukcja typu alias wymaga j\u0119zyka Python w wersji 3.12 lub nowszej",
+        typeAliasTypeBadScope: "Alias typu mo\u017Cna zdefiniowa\u0107 tylko w zakresie modu\u0142u lub klasy",
         typeAliasTypeBaseClass: 'A type alias defined in a "type" statement cannot be used as a base class',
         typeAliasTypeMustBeAssigned: "Typ TypeAliasType musi by\u0107 przypisany do zmiennej o takiej samej nazwie jak alias typu",
         typeAliasTypeNameArg: "Pierwszy argument dla typu TypeAliasType musi by\u0107 litera\u0142em ci\u0105gu reprezentuj\u0105cym nazw\u0119 aliasu typu",
@@ -24922,6 +24973,7 @@ var require_package_nls_pl = __commonJS({
         kwargsParamMissing: "Parametr \u201E**{paramName}\u201D nie ma odpowiadaj\u0105cego mu parametru",
         listAssignmentMismatch: "Typ \u201E{type}\u201D jest niezgodny z list\u0105 docelow\u0105",
         literalAssignmentMismatch: "Nie mo\u017Cna przypisa\u0107 typu \u201E{sourceType}\u201D do typu \u201E{destType}\u201D",
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: "Je\u015Bli kompleksowa obs\u0142uga nie jest zamierzona, dodaj \u201Ecase _: pass\u201D",
         matchIsNotExhaustiveType: "Nieobs\u0142ugiwany typ: \u201E{type}\u201D",
         memberAssignment: "Wyra\u017Cenia typu \u201E{type}\u201D nie mo\u017Cna przypisa\u0107 do atrybutu \u201E{name}\u201D klasy \u201E{classType}\u201D",
@@ -25119,6 +25171,7 @@ var require_package_nls_pt_br = __commonJS({
         baseClassUnknown: "O tipo de classe base \xE9 desconhecido, ocultando o tipo de classe derivada",
         baseClassVariableTypeIncompatible: 'Classes base para a classe "{classType}" definem a vari\xE1vel "{name}" de maneira incompat\xEDvel',
         binaryOperationNotAllowed: "Operador bin\xE1rio n\xE3o permitido na express\xE3o de tipo",
+        bindParamMissing: 'N\xE3o foi poss\xEDvel vincular o m\xE9todo "{methodName}" porque est\xE1 faltando um par\xE2metro "self" ou "cls"',
         bindTypeMismatch: 'N\xE3o foi poss\xEDvel associar o m\xE9todo "{methodName}" porque "{type}" n\xE3o \xE9 atribu\xEDvel ao par\xE2metro "{paramName}"',
         breakInExceptionGroup: '"break" n\xE3o \xE9 permitido em um bloco "except*"',
         breakOutsideLoop: '"break" s\xF3 pode ser usado dentro de um loop',
@@ -25550,6 +25603,7 @@ var require_package_nls_pt_br = __commonJS({
         typeAliasRedeclared: '"{name}" \xE9 declarado como um TypeAlias e s\xF3 pode ser atribu\xEDdo uma vez',
         typeAliasStatementBadScope: "Uma instru\xE7\xE3o type s\xF3 pode ser usada dentro de um m\xF3dulo ou escopo de classe",
         typeAliasStatementIllegal: "A instru\xE7\xE3o de alias de tipo requer o Python 3.12 ou mais recente",
+        typeAliasTypeBadScope: "Um alias de tipo s\xF3 pode ser definido dentro de um m\xF3dulo ou escopo de classe",
         typeAliasTypeBaseClass: 'Um alias de tipo definido em uma instru\xE7\xE3o "type" n\xE3o pode ser usado como uma classe base',
         typeAliasTypeMustBeAssigned: "TypeAliasType deve ser atribu\xEDdo a uma vari\xE1vel com o mesmo nome que o alias de tipo",
         typeAliasTypeNameArg: "O primeiro argumento para TypeAliasType deve ser um literal de cadeia de caracteres que representa o nome do alias de tipo",
@@ -25761,6 +25815,7 @@ var require_package_nls_pt_br = __commonJS({
         kwargsParamMissing: 'O par\xE2metro "**{paramName}" n\xE3o tem nenhum par\xE2metro correspondente',
         listAssignmentMismatch: 'O tipo "{type}" \xE9 incompat\xEDvel com a lista de destino',
         literalAssignmentMismatch: '"{sourceType}" n\xE3o pode ser atribu\xEDdo a o tipo"{destType}"',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: 'Se n\xE3o pretende usar a manipula\xE7\xE3o exaustiva, adicione "case _: pass"',
         matchIsNotExhaustiveType: 'Tipo sem tratamento: "{type}"',
         memberAssignment: 'A express\xE3o do tipo "{type}" n\xE3o pode ser atribu\xEDda ao atributo "{name}" da classe "{classType}"',
@@ -25958,6 +26013,7 @@ var require_package_nls_qps_ploc = __commonJS({
         baseClassUnknown: "[QQxIX][\u0E19\u0E31\u0E49\xDF\xE6s\xEB \xE7l\xE6ss t\xFFp\xEB \xEFs \xB5\xF1k\xF1\xF8w\xF1, \xF8\xFEs\xE7\xB5r\xEF\xF1g t\xFFp\xEB \xF8f \xF0\xEBr\xEFv\xEB\xF0 \xE7l\xE6ss\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         baseClassVariableTypeIncompatible: '[YmxlD][\u0E19\u0E31\u0E49\xDF\xE6s\xEB \xE7l\xE6ss\xEBs f\xF8r \xE7l\xE6ss "{\xE7l\xE6ssT\xFFp\xEB}" \xF0\xEBf\xEF\xF1\xEB v\xE6r\xEF\xE6\xFEl\xEB "{\xF1\xE6m\xEB}" \xEF\xF1 \xEF\xF1\xE7\xF8mp\xE6t\xEF\xFEl\xEB w\xE6\xFF\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         binaryOperationNotAllowed: "[1lzlz][\u0E19\u0E31\u0E49\xDF\xEF\xF1\xE6r\xFF \xF8p\xEBr\xE6t\xF8r \xF1\xF8t \xE6ll\xF8w\xEB\xF0 \xEF\xF1 t\xFFp\xEB \xEBxpr\xEBss\xEF\xF8\xF1\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
+        bindParamMissing: '[6ggqn][\u0E19\u0E31\u0E49\xC7\xF8\xB5l\xF0 \xF1\xF8t \xFE\xEF\xF1\xF0 m\xEBth\xF8\xF0 "{m\xEBth\xF8\xF0\xD1\xE6m\xEB}" \xFE\xEB\xE7\xE6\xB5s\xEB \xEFt \xEFs m\xEFss\xEF\xF1g \xE6 "s\xEBlf" \xF8r "\xE7ls" p\xE6r\xE6m\xEBt\xEBr\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         bindTypeMismatch: '[x4sbf][\u0E19\u0E31\u0E49\xC7\xF8\xB5l\xF0 \xF1\xF8t \xFE\xEF\xF1\xF0 m\xEBth\xF8\xF0 "{m\xEBth\xF8\xF0\xD1\xE6m\xEB}" \xFE\xEB\xE7\xE6\xB5s\xEB "{t\xFFp\xEB}" \xEFs \xF1\xF8t \xE6ss\xEFg\xF1\xE6\xFEl\xEB t\xF8 p\xE6r\xE6m\xEBt\xEBr "{p\xE6r\xE6m\xD1\xE6m\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         breakInExceptionGroup: '[Kwoku][\u0E19\u0E31\u0E49"break" \xEFs \xF1\xF8t \xE6ll\xF8w\xEB\xF0 \xEF\xF1 \xE6\xF1 "except*" \xFEl\xF8\xE7k\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         breakOutsideLoop: '[Ca4Ip][\u0E19\u0E31\u0E49"break" \xE7\xE6\xF1 \xFE\xEB \xB5s\xEB\xF0 \xF8\xF1l\xFF w\xEFth\xEF\xF1 \xE6 l\xF8\xF8p\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
@@ -26389,6 +26445,7 @@ var require_package_nls_qps_ploc = __commonJS({
         typeAliasRedeclared: '[P036x][\u0E19\u0E31\u0E49"{\xF1\xE6m\xEB}" \xEFs \xF0\xEB\xE7l\xE6r\xEB\xF0 \xE6s \xE6 TypeAlias \xE6\xF1\xF0 \xE7\xE6\xF1 \xFE\xEB \xE6ss\xEFg\xF1\xEB\xF0 \xF8\xF1l\xFF \xF8\xF1\xE7\xEB\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typeAliasStatementBadScope: "[C24Up][\u0E19\u0E31\u0E49\xC6 type st\xE6t\xEBm\xEB\xF1t \xE7\xE6\xF1 \xFE\xEB \xB5s\xEB\xF0 \xF8\xF1l\xFF w\xEFth\xEF\xF1 \xE6 m\xF8\xF0\xB5l\xEB \xF8r \xE7l\xE6ss s\xE7\xF8p\xEB\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typeAliasStatementIllegal: "[2EW0Q][\u0E19\u0E31\u0E49T\xFFp\xEB \xE6l\xEF\xE6s st\xE6t\xEBm\xEB\xF1t r\xEBq\xB5\xEFr\xEBs P\xFFth\xF8\xF1 3.12 \xF8r \xF1\xEBw\xEBr\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
+        typeAliasTypeBadScope: "[kdK34][\u0E19\u0E31\u0E49\xC6 t\xFFp\xEB \xE6l\xEF\xE6s \xE7\xE6\xF1 \xFE\xEB \xF0\xEBf\xEF\xF1\xEB\xF0 \xF8\xF1l\xFF w\xEFth\xEF\xF1 \xE6 m\xF8\xF0\xB5l\xEB \xF8r \xE7l\xE6ss s\xE7\xF8p\xEB\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typeAliasTypeBaseClass: '[RIpMs][\u0E19\u0E31\u0E49\xC6 t\xFFp\xEB \xE6l\xEF\xE6s \xF0\xEBf\xEF\xF1\xEB\xF0 \xEF\xF1 \xE6 "type" st\xE6t\xEBm\xEB\xF1t \xE7\xE6\xF1\xF1\xF8t \xFE\xEB \xB5s\xEB\xF0 \xE6s \xE6 \xFE\xE6s\xEB \xE7l\xE6ss\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typeAliasTypeMustBeAssigned: "[aV4Nn][\u0E19\u0E31\u0E49TypeAliasType m\xB5st \xFE\xEB \xE6ss\xEFg\xF1\xEB\xF0 t\xF8 \xE6 v\xE6r\xEF\xE6\xFEl\xEB w\xEFth th\xEB s\xE6m\xEB \xF1\xE6m\xEB \xE6s th\xEB t\xFFp\xEB \xE6l\xEF\xE6s\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typeAliasTypeNameArg: "[dUUf1][\u0E19\u0E31\u0E49F\xEFrst \xE6rg\xB5m\xEB\xF1t t\xF8 TypeAliasType m\xB5st \xFE\xEB \xE6 str\xEF\xF1g l\xEFt\xEBr\xE6l r\xEBpr\xEBs\xEB\xF1t\xEF\xF1g th\xEB \xF1\xE6m\xEB \xF8f th\xEB t\xFFp\xEB \xE6l\xEF\xE6s\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
@@ -26600,6 +26657,7 @@ var require_package_nls_qps_ploc = __commonJS({
         kwargsParamMissing: '[KHgb2][\u0E19\u0E31\u0E49P\xE6r\xE6m\xEBt\xEBr "**{p\xE6r\xE6m\xD1\xE6m\xEB}" h\xE6s \xF1\xF8 \xE7\xF8rr\xEBsp\xF8\xF1\xF0\xEF\xF1g p\xE6r\xE6m\xEBt\xEBr\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         listAssignmentMismatch: '[fERKI][\u0E19\u0E31\u0E49T\xFFp\xEB "{t\xFFp\xEB}" \xEFs \xEF\xF1\xE7\xF8mp\xE6t\xEF\xFEl\xEB w\xEFth t\xE6rg\xEBt l\xEFst\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         literalAssignmentMismatch: '[17LiQ][\u0E19\u0E31\u0E49"{s\xF8\xB5r\xE7\xEBT\xFFp\xEB}" \xEFs \xF1\xF8t \xE6ss\xEFg\xF1\xE6\xFEl\xEB t\xF8 t\xFFp\xEB "{\xF0\xEBstT\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
+        literalNotAllowed: '[kRsub][\u0E19\u0E31\u0E49"Literal" sp\xEB\xE7\xEF\xE6l f\xF8rm \xE7\xE6\xF1\xF1\xF8t \xFE\xEB \xB5s\xEB\xF0 w\xEFth \xEF\xF1st\xE6\xF1\xE7\xEB \xE6\xF1\xF0 \xE7l\xE6ss \xE7h\xEB\xE7ks\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         matchIsNotExhaustiveHint: '[3NR39][\u0E19\u0E31\u0E49\xCFf \xEBxh\xE6\xB5st\xEFv\xEB h\xE6\xF1\xF0l\xEF\xF1g \xEFs \xF1\xF8t \xEF\xF1t\xEB\xF1\xF0\xEB\xF0, \xE6\xF0\xF0 "case _: pass"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         matchIsNotExhaustiveType: '[9RN1P][\u0E19\u0E31\u0E49\xDC\xF1h\xE6\xF1\xF0l\xEB\xF0 t\xFFp\xEB: "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         memberAssignment: '[1WFCt][\u0E19\u0E31\u0E49\xCBxpr\xEBss\xEF\xF8\xF1 \xF8f t\xFFp\xEB "{t\xFFp\xEB}" \xE7\xE6\xF1\xF1\xF8t \xFE\xEB \xE6ss\xEFg\xF1\xEB\xF0 t\xF8 \xE6ttr\xEF\xFE\xB5t\xEB "{\xF1\xE6m\xEB}" \xF8f \xE7l\xE6ss "{\xE7l\xE6ssT\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
@@ -26797,6 +26855,7 @@ var require_package_nls_ru = __commonJS({
         baseClassUnknown: "\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 \u0442\u0438\u043F \u0431\u0430\u0437\u043E\u0432\u043E\u0433\u043E \u043A\u043B\u0430\u0441\u0441\u0430 \u0441\u043A\u0440\u044B\u0432\u0430\u0435\u0442 \u0442\u0438\u043F \u043F\u0440\u043E\u0438\u0437\u0432\u043E\u0434\u043D\u043E\u0433\u043E \u043A\u043B\u0430\u0441\u0441\u0430",
         baseClassVariableTypeIncompatible: '\u0411\u0430\u0437\u043E\u0432\u044B\u0435 \u043A\u043B\u0430\u0441\u0441\u044B \u043A\u043B\u0430\u0441\u0441\u0430 "{classType}" \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u044F\u044E\u0442 \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u0443\u044E "{name}" \u043D\u0435\u0441\u043E\u0432\u043C\u0435\u0441\u0442\u0438\u043C\u044B\u043C \u0441\u043F\u043E\u0441\u043E\u0431\u043E\u043C',
         binaryOperationNotAllowed: "\u0411\u0438\u043D\u0430\u0440\u043D\u044B\u0439 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 \u043D\u0435\u043B\u044C\u0437\u044F \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0432 \u0432\u044B\u0440\u0430\u0436\u0435\u043D\u0438\u0438 \u0442\u0438\u043F\u0430",
+        bindParamMissing: '\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u0438\u0432\u044F\u0437\u0430\u0442\u044C \u043C\u0435\u0442\u043E\u0434 "{methodName}", \u0442\u0430\u043A \u043A\u0430\u043A \u0432 \u043D\u0435\u043C \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 "self" \u0438\u043B\u0438 "cls"',
         bindTypeMismatch: '\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u0438\u0432\u044F\u0437\u0430\u0442\u044C \u043C\u0435\u0442\u043E\u0434 "{methodName}", "{type}" \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0443 "{paramName}"',
         breakInExceptionGroup: '\u0417\u0430\u043F\u0440\u0435\u0449\u0435\u043D\u043E \u043D\u0430\u043B\u0438\u0447\u0438\u0435 "break" \u0432 \u0431\u043B\u043E\u043A\u0435 "except*"',
         breakOutsideLoop: '"break" \u043C\u043E\u0436\u043D\u043E \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0442\u043E\u043B\u044C\u043A\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u0446\u0438\u043A\u043B\u0430',
@@ -27228,6 +27287,7 @@ var require_package_nls_ru = __commonJS({
         typeAliasRedeclared: '"{name}" \u043E\u0431\u044A\u044F\u0432\u043B\u0435\u043D \u043A\u0430\u043A TypeAlias \u0438 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u043F\u0440\u0438\u0441\u0432\u043E\u0435\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u043E\u0434\u0438\u043D \u0440\u0430\u0437',
         typeAliasStatementBadScope: "\u0423\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u0435 type \u043C\u043E\u0436\u043D\u043E \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0442\u043E\u043B\u044C\u043A\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u043E\u0431\u043B\u0430\u0441\u0442\u0438 \u043C\u043E\u0434\u0443\u043B\u044F \u0438\u043B\u0438 \u043A\u043B\u0430\u0441\u0441\u0430",
         typeAliasStatementIllegal: "\u041E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 \u043F\u0441\u0435\u0432\u0434\u043E\u043D\u0438\u043C\u0430 \u0442\u0438\u043F\u0430 \u043C\u043E\u0436\u043D\u043E \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0432 Python \u0432\u0435\u0440\u0441\u0438\u0438 \u043D\u0435 \u043D\u0438\u0436\u0435 3.12",
+        typeAliasTypeBadScope: "\u041F\u0441\u0435\u0432\u0434\u043E\u043D\u0438\u043C \u0442\u0438\u043F\u0430 \u043C\u043E\u0436\u043D\u043E \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u0442\u043E\u043B\u044C\u043A\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u043E\u0431\u043B\u0430\u0441\u0442\u0438 \u043C\u043E\u0434\u0443\u043B\u044F \u0438\u043B\u0438 \u043A\u043B\u0430\u0441\u0441\u0430",
         typeAliasTypeBaseClass: '\u041F\u0441\u0435\u0432\u0434\u043E\u043D\u0438\u043C \u0442\u0438\u043F\u0430, \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u044F\u0435\u043C\u044B\u0439 \u0432 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u0435 "type", \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C\u0441\u044F \u0432 \u043A\u0430\u0447\u0435\u0441\u0442\u0432\u0435 \u0431\u0430\u0437\u043E\u0432\u043E\u0433\u043E \u043A\u043B\u0430\u0441\u0441\u0430.',
         typeAliasTypeMustBeAssigned: "TypeAliasType \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u043E\u0439 \u0441 \u0442\u0435\u043C \u0436\u0435 \u0438\u043C\u0435\u043D\u0435\u043C, \u0447\u0442\u043E \u0438 \u043F\u0441\u0435\u0432\u0434\u043E\u043D\u0438\u043C \u0442\u0438\u043F\u0430",
         typeAliasTypeNameArg: "\u041F\u0435\u0440\u0432\u044B\u0439 \u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442 TypeAliasType \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0441\u0442\u0440\u043E\u043A\u043E\u0432\u044B\u043C \u043B\u0438\u0442\u0435\u0440\u0430\u043B\u043E\u043C, \u043F\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043B\u044F\u044E\u0449\u0438\u043C \u0438\u043C\u044F \u043F\u0441\u0435\u0432\u0434\u043E\u043D\u0438\u043C\u0430 \u0442\u0438\u043F\u0430",
@@ -27439,6 +27499,7 @@ var require_package_nls_ru = __commonJS({
         kwargsParamMissing: '\u0423 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0430 "**{paramName}" \u043D\u0435\u0442 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044E\u0449\u0435\u0433\u043E \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0430',
         listAssignmentMismatch: '\u0422\u0438\u043F "{type}" \u043D\u0435\u0441\u043E\u0432\u043C\u0435\u0441\u0442\u0438\u043C \u0441 \u0446\u0435\u043B\u0435\u0432\u044B\u043C \u0441\u043F\u0438\u0441\u043A\u043E\u043C',
         literalAssignmentMismatch: '"{sourceType}" \u043D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E \u043D\u0430\u0437\u043D\u0430\u0447\u0438\u0442\u044C \u0442\u0438\u043F "{destType}"',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: '\u0415\u0441\u043B\u0438 \u043D\u0435 \u043F\u0440\u0435\u0434\u043F\u043E\u043B\u0430\u0433\u0430\u0435\u0442\u0441\u044F \u0438\u0441\u0447\u0435\u0440\u043F\u044B\u0432\u0430\u044E\u0449\u0430\u044F \u043E\u0431\u0440\u0430\u0431\u043E\u0442\u043A\u0430, \u0434\u043E\u0431\u0430\u0432\u044C\u0442\u0435 "case _: pass"',
         matchIsNotExhaustiveType: '\u0422\u0438\u043F "{type}" \u043D\u0435 \u043E\u0431\u0440\u0430\u0431\u0430\u0442\u044B\u0432\u0430\u0435\u0442\u0441\u044F',
         memberAssignment: '\u0412\u044B\u0440\u0430\u0436\u0435\u043D\u0438\u0435 \u0442\u0438\u043F\u0430 "{type}" \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D\u043E \u0430\u0442\u0440\u0438\u0431\u0443\u0442\u0443 "{name}" \u043A\u043B\u0430\u0441\u0441\u0430 "{classType}"',
@@ -27636,6 +27697,7 @@ var require_package_nls_tr = __commonJS({
         baseClassUnknown: "Temel s\u0131n\u0131f t\xFCr\xFC bilinmiyor, t\xFCretilmi\u015F s\u0131n\u0131f\u0131 gizliyor",
         baseClassVariableTypeIncompatible: '"{classType}" s\u0131n\u0131f\u0131 i\xE7in temel s\u0131n\u0131flar, "{name}" de\u011Fi\u015Fkenini uyumsuz bir \u015Fekilde tan\u0131ml\u0131yor',
         binaryOperationNotAllowed: "T\xFCr ifadesinde ikili i\u015Fle\xE7 kullan\u0131lamaz",
+        bindParamMissing: '"self" veya "cls" parametresi eksik oldu\u011Fundan "{methodName}" y\xF6ntemi ba\u011Flanamad\u0131',
         bindTypeMismatch: '"{type}", "{paramName}" parametresine atanamad\u0131\u011F\u0131ndan "{methodName}" metodu ba\u011Flanamad\u0131',
         breakInExceptionGroup: '"except*" blo\u011Funda "break" kullan\u0131lamaz',
         breakOutsideLoop: '"break" yaln\u0131zca bir d\xF6ng\xFC i\xE7inde kullan\u0131labilir',
@@ -28067,6 +28129,7 @@ var require_package_nls_tr = __commonJS({
         typeAliasRedeclared: '"{name}" bir TypeAlias olarak bildirilmi\u015F ve yaln\u0131zca bir kez atanabilir',
         typeAliasStatementBadScope: "A type statement can be used only within a module or class scope",
         typeAliasStatementIllegal: "T\xFCr di\u011Fer ad\u0131 deyimi i\xE7in Python 3.12 veya daha yeni bir s\xFCr\xFCm\xFC gerekiyor",
+        typeAliasTypeBadScope: "T\xFCr di\u011Fer ad\u0131 yaln\u0131zca bir mod\xFCl veya s\u0131n\u0131f kapsam\u0131nda tan\u0131mlanabilir",
         typeAliasTypeBaseClass: 'Bir "type" deyiminde tan\u0131mlanan type di\u011Fer ad\u0131 temel s\u0131n\u0131f olarak kullan\u0131lamaz',
         typeAliasTypeMustBeAssigned: "TypeAliasType, t\xFCr di\u011Fer ad\u0131yla ayn\u0131 ada sahip bir de\u011Fi\u015Fkene atanmal\u0131d\u0131r",
         typeAliasTypeNameArg: "TypeAliasType i\xE7in ilk ba\u011F\u0131ms\u0131z de\u011Fi\u015Fken, t\xFCr di\u011Fer ad\u0131n\u0131n ad\u0131n\u0131 temsil eden bir sabit de\u011Ferli dize olmal\u0131d\u0131r",
@@ -28278,6 +28341,7 @@ var require_package_nls_tr = __commonJS({
         kwargsParamMissing: '"**{paramName}" parametresine kar\u015F\u0131l\u0131k gelen bir parametre yok',
         listAssignmentMismatch: '"{type}" t\xFCr\xFC hedef listeyle uyumsuz',
         literalAssignmentMismatch: '"{sourceType}" "{destType}" t\xFCr\xFCne atanamaz',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: 'T\xFCmlemeli i\u015Fleme ama\xE7lanmad\u0131ysa "case _: pass" ekleyin',
         matchIsNotExhaustiveType: '"{type}" t\xFCr\xFC i\u015Flenmemi\u015F',
         memberAssignment: '"{type}" t\xFCr\xFCndeki ifade, "{classType}" s\u0131n\u0131f\u0131n\u0131n "{name}" \xF6zniteli\u011Fine atanamaz',
@@ -28475,6 +28539,7 @@ var require_package_nls_zh_cn = __commonJS({
         baseClassUnknown: "\u57FA\u7C7B\u7C7B\u578B\u672A\u77E5\uFF0C\u9690\u853D\u6D3E\u751F\u7C7B\u7684\u7C7B\u578B",
         baseClassVariableTypeIncompatible: "\u7C7B\u201C{classType}\u201D\u7684\u57FA\u7C7B\u4EE5\u4E0D\u517C\u5BB9\u7684\u65B9\u5F0F\u5B9A\u4E49\u53D8\u91CF\u201C{name}\u201D",
         binaryOperationNotAllowed: "\u7C7B\u578B\u8868\u8FBE\u5F0F\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u4E8C\u5143\u8FD0\u7B97\u7B26",
+        bindParamMissing: "\u65E0\u6CD5\u7ED1\u5B9A\u65B9\u6CD5\u201C{methodName}\u201D\uFF0C\u56E0\u4E3A\u5B83\u7F3A\u5C11 \u201Cself\u201D \u6216 \u201Ccls\u201D \u53C2\u6570",
         bindTypeMismatch: "\u65E0\u6CD5\u7ED1\u5B9A\u65B9\u6CD5\u201C{methodName}\u201D\uFF0C\u56E0\u4E3A\u201C{type}\u201D\u4E0D\u80FD\u5206\u914D\u7ED9\u53C2\u6570\u201C{paramName}\u201D",
         breakInExceptionGroup: '"except*" \u5757\u4E2D\u4E0D\u5141\u8BB8 "break"',
         breakOutsideLoop: "\u201Cbreak\u201D\u53EA\u80FD\u5728\u5FAA\u73AF\u4E2D\u4F7F\u7528",
@@ -28906,6 +28971,7 @@ var require_package_nls_zh_cn = __commonJS({
         typeAliasRedeclared: "\u201C{name}\u201D\u58F0\u660E\u4E3A TypeAlias\uFF0C\u53EA\u80FD\u5206\u914D\u4E00\u6B21",
         typeAliasStatementBadScope: "type \u8BED\u53E5\u53EA\u80FD\u5728\u6A21\u5757\u6216\u7C7B\u8303\u56F4\u5185\u4F7F\u7528",
         typeAliasStatementIllegal: "\u7C7B\u578B\u522B\u540D\u8BED\u53E5\u9700\u8981 Python 3.12 \u6216\u66F4\u9AD8\u7248\u672C",
+        typeAliasTypeBadScope: "\u53EA\u80FD\u5728\u6A21\u5757\u6216\u7C7B\u8303\u56F4\u5185\u5B9A\u4E49\u7C7B\u578B\u522B\u540D",
         typeAliasTypeBaseClass: '"type" \u8BED\u53E5\u4E2D\u5B9A\u4E49\u7684\u7C7B\u578B\u522B\u540D\u4E0D\u80FD\u7528\u4F5C\u57FA\u7C7B',
         typeAliasTypeMustBeAssigned: "\u5FC5\u987B\u5C06 TypeAliasType \u5206\u914D\u7ED9\u4E0E\u7C7B\u578B\u522B\u540D\u540C\u540D\u7684\u53D8\u91CF",
         typeAliasTypeNameArg: "TypeAliasType \u7684\u7B2C\u4E00\u4E2A\u53C2\u6570\u5FC5\u987B\u662F\u8868\u793A\u7C7B\u578B\u522B\u540D\u540D\u79F0\u7684\u5B57\u7B26\u4E32\u6587\u672C",
@@ -29117,6 +29183,7 @@ var require_package_nls_zh_cn = __commonJS({
         kwargsParamMissing: "\u53C2\u6570\u201C**{paramName}\u201D\u6CA1\u6709\u76F8\u5E94\u7684\u53C2\u6570",
         listAssignmentMismatch: "\u7C7B\u578B\u201C{type}\u201D\u4E0E\u76EE\u6807\u5217\u8868\u4E0D\u517C\u5BB9",
         literalAssignmentMismatch: "\u201C{sourceType}\u201D\u4E0D\u53EF\u5206\u914D\u7ED9\u7C7B\u578B\u201C{destType}\u201D",
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: '\u5982\u679C\u672A\u8FDB\u884C\u8BE6\u5C3D\u5904\u7406\uFF0C\u8BF7\u6DFB\u52A0"case _: pass"',
         matchIsNotExhaustiveType: '\u672A\u5904\u7406\u7684\u7C7B\u578B: "{type}"',
         memberAssignment: "\u65E0\u6CD5\u5C06\u7C7B\u578B\u201C{type}\u201D\u7684\u8868\u8FBE\u5F0F\u5206\u914D\u7ED9\u7C7B\u201C{classType}\u201D\u7684\u5C5E\u6027\u201C{name}\u201D",
@@ -29314,6 +29381,7 @@ var require_package_nls_zh_tw = __commonJS({
         baseClassUnknown: "\u57FA\u5E95\u985E\u5225\u985E\u578B\u672A\u77E5\uFF0C\u906E\u853D\u884D\u751F\u985E\u5225\u7684\u985E\u578B",
         baseClassVariableTypeIncompatible: '\u985E\u5225 "{classType}" \u7684\u57FA\u5E95\u985E\u5225\u4EE5\u4E0D\u76F8\u5BB9\u7684\u65B9\u5F0F\u5B9A\u7FA9\u8B8A\u6578 "{name}"',
         binaryOperationNotAllowed: "\u985E\u578B\u904B\u7B97\u5F0F\u4E2D\u4E0D\u5141\u8A31\u4E8C\u5143\u904B\u7B97\u5B50",
+        bindParamMissing: '\u7121\u6CD5\u7E6B\u7D50\u65B9\u6CD5 "{methodName}"\uFF0C\u56E0\u70BA\u7F3A\u5C11 "self" \u6216 "cls" \u53C3\u6578',
         bindTypeMismatch: '\u7121\u6CD5\u7E6B\u7D50\u65B9\u6CD5 "{methodName}"\uFF0C\u56E0\u70BA "{type}" \u7121\u6CD5\u6307\u6D3E\u7D66\u53C3\u6578 "{paramName}"',
         breakInExceptionGroup: '"except*" \u5340\u584A\u4E2D\u4E0D\u5141\u8A31 "break"',
         breakOutsideLoop: '"break" \u53EA\u80FD\u5728\u8FF4\u5708\u5167\u4F7F\u7528',
@@ -29745,6 +29813,7 @@ var require_package_nls_zh_tw = __commonJS({
         typeAliasRedeclared: '"{name}" \u5BA3\u544A\u70BA TypeAlias\uFF0C\u4E14\u53EA\u80FD\u6307\u6D3E\u4E00\u6B21',
         typeAliasStatementBadScope: "A type statement can be used only within a module or class scope",
         typeAliasStatementIllegal: "\u985E\u578B\u5225\u540D\u9673\u8FF0\u5F0F\u9700\u8981 Python 3.12 \u6216\u66F4\u65B0\u7248\u672C",
+        typeAliasTypeBadScope: "\u985E\u578B\u5225\u540D\u53EA\u80FD\u5728\u6A21\u7D44\u6216\u985E\u5225\u7BC4\u570D\u5167\u5B9A\u7FA9",
         typeAliasTypeBaseClass: '"type" \u9673\u8FF0\u5F0F\u4E2D\u5B9A\u7FA9\u7684\u985E\u578B\u5225\u540D\u4E0D\u80FD\u505A\u70BA\u57FA\u5E95\u985E\u5225\u4F7F\u7528',
         typeAliasTypeMustBeAssigned: "TypeAliasType \u5FC5\u9808\u6307\u6D3E\u7D66\u8207\u578B\u5225\u5225\u540D\u76F8\u540C\u7684\u8B8A\u6578",
         typeAliasTypeNameArg: "TypeAliasType \u7684\u7B2C\u4E00\u500B\u5F15\u6578\u5FC5\u9808\u662F\u4EE3\u8868\u578B\u5225\u5225\u540D\u540D\u7A31\u7684\u5B57\u4E32\u5E38\u503C",
@@ -29956,6 +30025,7 @@ var require_package_nls_zh_tw = __commonJS({
         kwargsParamMissing: '\u53C3\u6578 "**{paramName}" \u6C92\u6709\u5C0D\u61C9\u7684\u53C3\u6578',
         listAssignmentMismatch: '\u985E\u578B "{type}" \u8207\u76EE\u6A19\u6E05\u55AE\u4E0D\u76F8\u5BB9',
         literalAssignmentMismatch: '"{sourceType}" \u7121\u6CD5\u6307\u6D3E\u7D66\u578B\u5225 "{destType}"',
+        literalNotAllowed: '"Literal" special form cannot be used with instance and class checks',
         matchIsNotExhaustiveHint: '\u5982\u679C\u4E0D\u9700\u8981\u5FB9\u5E95\u8655\u7406\uFF0C\u8ACB\u65B0\u589E "case _: pass"',
         matchIsNotExhaustiveType: '\u672A\u8655\u7406\u7684\u985E\u578B: "{type}"',
         memberAssignment: '\u7121\u6CD5\u5C07\u578B\u5225 "{type}" \u7684\u904B\u7B97\u5F0F\u6307\u6D3E\u7D66\u985E\u5225 "{classType}" \u7684\u5C6C\u6027 "{name}"',
@@ -30453,6 +30523,9 @@ var require_localize = __commonJS({
         Diagnostic4.finalClassIsAbstract = () => new ParameterizedString(getRawString("Diagnostic.finalClassIsAbstract"));
         Diagnostic4.finalContext = () => getRawString("Diagnostic.finalContext");
         Diagnostic4.finalInLoop = () => getRawString("Diagnostic.finalInLoop");
+        Diagnostic4.finallyBreak = () => getRawString("Diagnostic.finallyBreak");
+        Diagnostic4.finallyContinue = () => getRawString("Diagnostic.finallyContinue");
+        Diagnostic4.finallyReturn = () => getRawString("Diagnostic.finallyReturn");
         Diagnostic4.finalMethodOverride = () => new ParameterizedString(getRawString("Diagnostic.finalMethodOverride"));
         Diagnostic4.finalNonMethod = () => new ParameterizedString(getRawString("Diagnostic.finalNonMethod"));
         Diagnostic4.finalReassigned = () => new ParameterizedString(getRawString("Diagnostic.finalReassigned"));
@@ -30553,6 +30626,7 @@ var require_localize = __commonJS({
         Diagnostic4.namedParamAfterParamSpecArgs = () => new ParameterizedString(getRawString("Diagnostic.namedParamAfterParamSpecArgs"));
         Diagnostic4.namedTupleEmptyName = () => getRawString("Diagnostic.namedTupleEmptyName");
         Diagnostic4.namedTupleEntryRedeclared = () => new ParameterizedString(getRawString("Diagnostic.namedTupleEntryRedeclared"));
+        Diagnostic4.namedTupleFieldUnderscore = () => getRawString("Diagnostic.namedTupleFieldUnderscore");
         Diagnostic4.namedTupleFirstArg = () => getRawString("Diagnostic.namedTupleFirstArg");
         Diagnostic4.namedTupleMultipleInheritance = () => getRawString("Diagnostic.namedTupleMultipleInheritance");
         Diagnostic4.namedTupleNameKeyword = () => getRawString("Diagnostic.namedTupleNameKeyword");
@@ -30938,6 +31012,7 @@ var require_localize = __commonJS({
         DiagnosticAddendum2.kwargsParamMissing = () => new ParameterizedString(getRawString("DiagnosticAddendum.kwargsParamMissing"));
         DiagnosticAddendum2.listAssignmentMismatch = () => new ParameterizedString(getRawString("DiagnosticAddendum.listAssignmentMismatch"));
         DiagnosticAddendum2.literalAssignmentMismatch = () => new ParameterizedString(getRawString("DiagnosticAddendum.literalAssignmentMismatch"));
+        DiagnosticAddendum2.literalNotAllowed = () => getRawString("DiagnosticAddendum.literalNotAllowed");
         DiagnosticAddendum2.matchIsNotExhaustiveType = () => new ParameterizedString(getRawString("DiagnosticAddendum.matchIsNotExhaustiveType"));
         DiagnosticAddendum2.matchIsNotExhaustiveHint = () => getRawString("DiagnosticAddendum.matchIsNotExhaustiveHint");
         DiagnosticAddendum2.memberAssignment = () => new ParameterizedString(getRawString("DiagnosticAddendum.memberAssignment"));
@@ -33007,6 +33082,9 @@ var require_codeFlowTypes = __commonJS({
       if (reference.nodeType === 35) {
         return isCodeFlowSupportedForReference(reference.d.leftExpr);
       }
+      if (reference.nodeType === 4) {
+        return true;
+      }
       if (reference.nodeType === 27) {
         if (reference.d.items.length !== 1 || reference.d.trailingComma || reference.d.items[0].d.name !== void 0 || reference.d.items[0].d.argCategory !== 0) {
           return false;
@@ -33026,6 +33104,8 @@ var require_codeFlowTypes = __commonJS({
       let key;
       if (reference.nodeType === 38) {
         key = reference.d.value;
+      } else if (reference.nodeType === 4) {
+        key = reference.d.name.d.value;
       } else if (reference.nodeType === 35) {
         const leftKey = createKeyForReference(reference.d.leftExpr);
         key = `${leftKey}.${reference.d.member.d.value}`;
@@ -33056,6 +33136,9 @@ var require_codeFlowTypes = __commonJS({
       if (reference.nodeType === 38) {
         return [createKeyForReference(reference)];
       }
+      if (reference.nodeType === 4) {
+        return [createKeyForReference(reference.d.name)];
+      }
       if (reference.nodeType === 35) {
         return [
           ...createKeysForReferenceSubexpressions(reference.d.leftExpr),
@@ -33126,9 +33209,6 @@ var require_analyzerNodeInfo = __commonJS({
       if (info == null ? void 0 : info.dunderAllInfo) {
         info.dunderAllInfo = void 0;
       }
-      if (info == null ? void 0 : info.typeParamSymbol) {
-        info.typeParamSymbol = void 0;
-      }
     }
     function getImportInfo(node) {
       const info = getAnalyzerInfo(node);
@@ -33993,6 +34073,8 @@ var require_parseTreeUtils = __commonJS({
     exports2.checkDecorator = checkDecorator;
     exports2.isSimpleDefault = isSimpleDefault;
     exports2.getPreviousNonWhitespaceToken = getPreviousNonWhitespaceToken;
+    exports2.getNextNonWhitespaceToken = getNextNonWhitespaceToken;
+    exports2.getNextMatchingToken = getNextMatchingToken;
     var AnalyzerNodeInfo = __importStar(require_analyzerNodeInfo());
     var core_1 = require_core();
     var debug_1 = require_debug();
@@ -35018,12 +35100,22 @@ var require_parseTreeUtils = __commonJS({
       walker.walk(node);
       return foundAwait;
     }
-    function isMatchingExpression(reference, expression) {
+    function isMatchingExpression(reference, expression, compareName) {
       if (reference.nodeType === 38) {
+        let nameToCompare;
         if (expression.nodeType === 38) {
-          return reference.d.value === expression.d.value;
+          nameToCompare = expression;
         } else if (expression.nodeType === 4) {
-          return reference.d.value === expression.d.name.d.value;
+          nameToCompare = expression.d.name;
+        }
+        if (nameToCompare) {
+          if (reference.d.value !== nameToCompare.d.value) {
+            return false;
+          }
+          if (compareName) {
+            return compareName(reference, nameToCompare);
+          }
+          return true;
         }
         return false;
       } else if (reference.nodeType === 35 && expression.nodeType === 35) {
@@ -36126,6 +36218,23 @@ var require_parseTreeUtils = __commonJS({
       }
       return void 0;
     }
+    function getNextNonWhitespaceToken(tokens, offset) {
+      return getNextMatchingToken(tokens, offset, (token) => !isWhitespace(token));
+    }
+    function getNextMatchingToken(tokens, offset, match2, exit = () => false) {
+      let tokenIndex = tokens.getItemAtPosition(offset) + 1;
+      while (tokenIndex < tokens.count) {
+        const token = tokens.getItemAt(tokenIndex);
+        if (match2(token)) {
+          return token;
+        }
+        if (exit(token)) {
+          return void 0;
+        }
+        tokenIndex += 1;
+      }
+      return void 0;
+    }
   }
 });
 
@@ -41154,6 +41263,7 @@ var require_tokenizer = __commonJS({
     exports2.Tokenizer = void 0;
     var parseTreeUtils_1 = require_parseTreeUtils();
     var sourceFile_1 = require_sourceFile();
+    var core_1 = require_core();
     var textRangeCollection_1 = require_textRangeCollection();
     var characters_1 = require_characters();
     var characterStream_1 = require_characterStream();
@@ -42024,7 +42134,7 @@ var require_tokenizer = __commonJS({
           if (_keywords.has(value)) {
             this._tokens.push(tokenizerTypes_1.KeywordToken.create(start, this._cs.position - start, _keywords.get(value), this._getComments()));
           } else {
-            this._tokens.push(tokenizerTypes_1.IdentifierToken.create(start, this._cs.position - start, value, this._getComments()));
+            this._tokens.push(tokenizerTypes_1.IdentifierToken.create(start, this._cs.position - start, (0, core_1.cloneStr)(value), this._getComments()));
           }
           return true;
         }
@@ -42361,7 +42471,7 @@ var require_tokenizer = __commonJS({
           if (endTrimmed.length > 0) {
             commentRules.push({
               range: { start: currentOffset, length: endTrimmed.length },
-              text: endTrimmed
+              text: (0, core_1.cloneStr)(endTrimmed)
             });
           }
           currentOffset += frontTrimmed.length + 1;
@@ -42399,8 +42509,6 @@ var require_tokenizer = __commonJS({
           switch (prefix) {
             case "rf":
             case "fr":
-            case "ur":
-            case "ru":
             case "br":
             case "rb":
               return 2;
@@ -43625,7 +43733,7 @@ var require_binder = __commonJS({
             this._addImplicitSymbolToCurrentScope("__loader__", node, "Any");
             this._addImplicitSymbolToCurrentScope("__package__", node, "str | None");
             this._addImplicitSymbolToCurrentScope("__spec__", node, "Any");
-            this._addImplicitSymbolToCurrentScope("__path__", node, "Iterable[str]");
+            this._addImplicitSymbolToCurrentScope("__path__", node, "MutableSequence[str]");
             this._addImplicitSymbolToCurrentScope("__file__", node, "str");
             this._addImplicitSymbolToCurrentScope("__cached__", node, "str");
             this._addImplicitSymbolToCurrentScope("__dict__", node, "Dict[str, Any]");
@@ -43685,6 +43793,7 @@ var require_binder = __commonJS({
         return false;
       }
       visitModuleName(node) {
+        var _a;
         const importResult = AnalyzerNodeInfo.getImportInfo(node);
         (0, debug_1.assert)(importResult !== void 0);
         if (importResult.isNativeLib) {
@@ -43697,7 +43806,19 @@ var require_binder = __commonJS({
           }), node);
           return true;
         }
+        let reportStubMissing = false;
         if (!importResult.isStubFile && importResult.importType === 1 && !importResult.pyTypedInfo) {
+          reportStubMissing = true;
+          if (importResult.isNamespacePackage && ((_a = node.parent) == null ? void 0 : _a.nodeType) === 25) {
+            if (node.parent.d.imports.every((importAs) => {
+              const implicitImport = importResult.filteredImplicitImports.get(importAs.d.name.d.value);
+              return !!(implicitImport == null ? void 0 : implicitImport.pyTypedInfo);
+            })) {
+              reportStubMissing = false;
+            }
+          }
+        }
+        if (reportStubMissing) {
           const diagnostic = this._addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeStubs, localize_1.LocMessage.stubFileMissing().format({ importName: importResult.importName }), node);
           if (diagnostic) {
             const createTypeStubAction = {
@@ -44329,6 +44450,7 @@ var require_binder = __commonJS({
           this._targetFunctionDeclaration.returnStatements.push(node);
         }
         if (node.d.expr) {
+          AnalyzerNodeInfo.setFlowNode(node.d.expr, this._currentFlowNode);
           this.walk(node.d.expr);
         }
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
@@ -46756,6 +46878,7 @@ var require_types = __commonJS({
     exports2.isUnpacked = isUnpacked;
     exports2.isFunction = isFunction;
     exports2.isOverloaded = isOverloaded;
+    exports2.isFunctionOrOverloaded = isFunctionOrOverloaded;
     exports2.getTypeAliasInfo = getTypeAliasInfo;
     exports2.isTypeSame = isTypeSame;
     exports2.removeUnknownFromUnion = removeUnknownFromUnion;
@@ -47567,6 +47690,15 @@ var require_types = __commonJS({
           }
           return true;
         }
+        const subclassDepth = TypeBase.getInstantiableDepth(subclassType);
+        if (subclassDepth > 0) {
+          if (isBuiltIn(parentClassType, "type") && TypeBase.getInstantiableDepth(parentClassType) < subclassDepth) {
+            if (inheritanceChain) {
+              inheritanceChain.push(parentClassType);
+            }
+            return true;
+          }
+        }
         if (ClassType2.isBuiltIn(subclassType, "property") && ClassType2.isBuiltIn(parentClassType, "property")) {
           if (inheritanceChain) {
             inheritanceChain.push(subclassType);
@@ -47712,16 +47844,14 @@ var require_types = __commonJS({
         if (stripFirstParam) {
           if (type.shared.parameters.length > 0) {
             if (type.shared.parameters[0].category === 0) {
-              if (type.shared.parameters.length > 0 && !FunctionParam.isTypeInferred(type.shared.parameters[0])) {
-                newFunction.priv.strippedFirstParamType = getParamType(type, 0);
+              if (type.shared.parameters.length > 0) {
+                newFunction.priv.strippedFirstParamType = FunctionParam.isTypeInferred(type.shared.parameters[0]) ? AnyType.create() : getParamType(type, 0);
               }
               newFunction.shared.parameters = type.shared.parameters.slice(1);
             }
           } else {
             stripFirstParam = false;
           }
-          newFunction.shared.flags &= ~(1 | 2);
-          newFunction.shared.flags |= 4;
         }
         if ((_a = type.props) == null ? void 0 : _a.typeAliasInfo) {
           TypeBase.setTypeAliasInfo(newFunction, type.props.typeAliasInfo);
@@ -47733,7 +47863,7 @@ var require_types = __commonJS({
             returnType: type.priv.specializedTypes.returnType
           };
         }
-        newFunction.priv.inferredReturnType = type.priv.inferredReturnType;
+        newFunction.shared.inferredReturnType = type.shared.inferredReturnType;
         return newFunction;
       }
       FunctionType2.clone = clone;
@@ -47766,20 +47896,13 @@ var require_types = __commonJS({
         return newInstance;
       }
       FunctionType2.cloneAsInstantiable = cloneAsInstantiable;
-      function specialize(type, specializedTypes, specializedInferredReturnType) {
-        var _a;
+      function specialize(type, specializedTypes) {
         const newFunction = TypeBase.cloneType(type);
         (0, debug_1.assert)(specializedTypes.parameterTypes.length === type.shared.parameters.length);
         if (specializedTypes.parameterDefaultTypes) {
           (0, debug_1.assert)(specializedTypes.parameterDefaultTypes.length === type.shared.parameters.length);
         }
         newFunction.priv.specializedTypes = specializedTypes;
-        if (specializedInferredReturnType) {
-          newFunction.priv.inferredReturnType = {
-            type: specializedInferredReturnType,
-            isIncomplete: (_a = type.priv.inferredReturnType) == null ? void 0 : _a.isIncomplete
-          };
-        }
         return newFunction;
       }
       FunctionType2.specialize = specialize;
@@ -47895,8 +48018,8 @@ var require_types = __commonJS({
             newFunction.priv.specializedTypes.parameterDefaultTypes = newFunction.priv.specializedTypes.parameterDefaultTypes.slice(0, newFunction.priv.specializedTypes.parameterDefaultTypes.length - paramsToDrop);
           }
         }
-        if (type.priv.inferredReturnType) {
-          newFunction.priv.inferredReturnType = type.priv.inferredReturnType;
+        if (type.shared.inferredReturnType) {
+          newFunction.shared.inferredReturnType = type.shared.inferredReturnType;
         }
         return newFunction;
       }
@@ -48095,7 +48218,7 @@ var require_types = __commonJS({
           return type.shared.declaredReturnType;
         }
         if (includeInferred) {
-          return (_b = type.priv.inferredReturnType) == null ? void 0 : _b.type;
+          return (_b = type.shared.inferredReturnType) == null ? void 0 : _b.type;
         }
         return void 0;
       }
@@ -48734,6 +48857,9 @@ var require_types = __commonJS({
     function isOverloaded(type) {
       return type.category === 5;
     }
+    function isFunctionOrOverloaded(type) {
+      return type.category === 4 || type.category === 5;
+    }
     function getTypeAliasInfo(type) {
       var _a, _b;
       if ((_a = type.props) == null ? void 0 : _a.typeAliasInfo) {
@@ -48881,15 +49007,15 @@ var require_types = __commonJS({
           if (type1.priv.specializedTypes && type1.priv.specializedTypes.returnType) {
             return1Type = type1.priv.specializedTypes.returnType;
           }
-          if (!return1Type && type1.priv.inferredReturnType) {
-            return1Type = (_e = type1.priv.inferredReturnType) == null ? void 0 : _e.type;
+          if (!return1Type && type1.shared.inferredReturnType) {
+            return1Type = (_e = type1.shared.inferredReturnType) == null ? void 0 : _e.type;
           }
           let return2Type = functionType2.shared.declaredReturnType;
           if (functionType2.priv.specializedTypes && functionType2.priv.specializedTypes.returnType) {
             return2Type = functionType2.priv.specializedTypes.returnType;
           }
-          if (!return2Type && functionType2.priv.inferredReturnType) {
-            return2Type = (_f = functionType2.priv.inferredReturnType) == null ? void 0 : _f.type;
+          if (!return2Type && functionType2.shared.inferredReturnType) {
+            return2Type = (_f = functionType2.shared.inferredReturnType) == null ? void 0 : _f.type;
           }
           if (return1Type || return2Type) {
             if (!return1Type || !return2Type || !isTypeSame(return1Type, return2Type, { ...options, ignoreTypeFlags: false }, recursionCount)) {
@@ -49422,7 +49548,7 @@ var require_typeWalker = __commonJS({
           }
         }
         if (!this._isWalkCanceled && !types_1.FunctionType.isParamSpecValue(type) && !types_1.FunctionType.isParamSpecValue(type)) {
-          const returnType = type.shared.declaredReturnType ?? ((_a = type.priv.inferredReturnType) == null ? void 0 : _a.type);
+          const returnType = type.shared.declaredReturnType ?? ((_a = type.shared.inferredReturnType) == null ? void 0 : _a.type);
           if (returnType) {
             this.walk(returnType);
           }
@@ -50135,7 +50261,10 @@ var require_typeUtils = __commonJS({
         if (type === typeAliasPlaceholder) {
           return true;
         }
-        return (0, types_1.isUnbound)(type) && ((_a = type.props) == null ? void 0 : _a.typeAliasInfo) && type.props.typeAliasInfo.shared.name === ((_b = typeAliasPlaceholder.shared.recursiveAlias) == null ? void 0 : _b.name);
+        if (!(0, types_1.isUnbound)(type) && !isTypeAliasPlaceholder(type)) {
+          return false;
+        }
+        return ((_a = type.props) == null ? void 0 : _a.typeAliasInfo) && type.props.typeAliasInfo.shared.name === ((_b = typeAliasPlaceholder.shared.recursiveAlias) == null ? void 0 : _b.name);
       }
       return (0, types_1.findSubtype)(type, (subtype) => (0, types_1.isTypeVar)(subtype) && subtype.shared === typeAliasPlaceholder.shared) !== void 0;
     }
@@ -50384,7 +50513,7 @@ var require_typeUtils = __commonJS({
       return (0, types_1.isClassInstance)(type) && types_1.ClassType.isPropertyClass(type);
     }
     function isCallableType(type) {
-      if ((0, types_1.isFunction)(type) || (0, types_1.isOverloaded)(type) || (0, types_1.isAnyOrUnknown)(type)) {
+      if ((0, types_1.isFunctionOrOverloaded)(type) || (0, types_1.isAnyOrUnknown)(type)) {
         return true;
       }
       if (isEffectivelyInstantiable(type)) {
@@ -51531,8 +51660,8 @@ var require_typeUtils = __commonJS({
             if (requiresSpecialization(declaredReturnType, options, recursionCount)) {
               return true;
             }
-          } else if (type.priv.inferredReturnType) {
-            if (requiresSpecialization((_b = type.priv.inferredReturnType) == null ? void 0 : _b.type, options, recursionCount)) {
+          } else if (type.shared.inferredReturnType) {
+            if (requiresSpecialization((_b = type.shared.inferredReturnType) == null ? void 0 : _b.type, options, recursionCount)) {
               return true;
             }
           }
@@ -52114,9 +52243,10 @@ var require_typeUtils = __commonJS({
             }
           }
           let specializedInferredReturnType;
-          if (functionType.priv.inferredReturnType) {
-            specializedInferredReturnType = this.apply((_a = functionType.priv.inferredReturnType) == null ? void 0 : _a.type, recursionCount);
-            if (specializedInferredReturnType !== ((_b = functionType.priv.inferredReturnType) == null ? void 0 : _b.type)) {
+          if (functionType.shared.inferredReturnType) {
+            specializedInferredReturnType = this.apply((_a = functionType.shared.inferredReturnType) == null ? void 0 : _a.type, recursionCount);
+            if (specializedInferredReturnType !== ((_b = functionType.shared.inferredReturnType) == null ? void 0 : _b.type)) {
+              specializedParams.returnType = specializedInferredReturnType;
               typesRequiredSpecialization = true;
             }
           }
@@ -52131,7 +52261,7 @@ var require_typeUtils = __commonJS({
               );
             }
           }
-          if (functionType.priv.strippedFirstParamType) {
+          if (functionType.priv.strippedFirstParamType && !(0, types_1.isAnyOrUnknown)(functionType.priv.strippedFirstParamType)) {
             const newStrippedType = this.apply(functionType.priv.strippedFirstParamType, recursionCount);
             if (newStrippedType !== functionType.priv.strippedFirstParamType) {
               functionType = types_1.TypeBase.cloneType(functionType);
@@ -52145,7 +52275,7 @@ var require_typeUtils = __commonJS({
             specializedParams.parameterDefaultTypes = specializedDefaultArgs;
           }
           if (!variadicTypesToUnpack) {
-            return types_1.FunctionType.specialize(functionType, specializedParams, specializedInferredReturnType);
+            return types_1.FunctionType.specialize(functionType, specializedParams);
           }
           const newFunctionType = types_1.TypeBase.isInstantiable(functionType) ? types_1.FunctionType.createInstantiable(
             functionType.shared.flags | 64
@@ -52238,7 +52368,7 @@ var require_typeUtils = __commonJS({
               }
             });
             updatedSourceType = applySolvedTypeVars(sourceType, solution);
-            (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloaded)(updatedSourceType));
+            (0, debug_1.assert)((0, types_1.isFunctionOrOverloaded)(updatedSourceType));
           }
         }
         this._signatureTracker.addSignature(sourceType, this._expressionOffset);
@@ -54543,7 +54673,7 @@ var require_constraintSolver = __commonJS({
       }
       if (destType.shared.boundType) {
         const updatedType = newLowerBound || newUpperBound;
-        if (types_1.TypeBase.isInstantiable(destType) && !(0, typeUtils_1.isEffectivelyInstantiable)(srcType)) {
+        if (types_1.TypeBase.isInstantiable(destType) && !(0, typeUtils_1.isEffectivelyInstantiable)(srcType, { honorTypeVarBounds: true })) {
           return false;
         }
         const effectiveConstraints = types_1.TypeVarType.isSelf(destType) ? constraints : void 0;
@@ -54868,11 +54998,12 @@ var require_parameterUtils = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/analyzer/parameterUtils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ParamKind = void 0;
+    exports2.ParamAssignmentTracker = exports2.ParamKind = void 0;
     exports2.isTypedKwargs = isTypedKwargs;
     exports2.getParamListDetails = getParamListDetails;
     exports2.isParamSpecArgs = isParamSpecArgs;
     exports2.isParamSpecKwargs = isParamSpecKwargs;
+    var debug_1 = require_debug();
     var symbolNameUtils_1 = require_symbolNameUtils();
     var types_1 = require_types();
     var typeUtils_1 = require_typeUtils();
@@ -55044,7 +55175,7 @@ var require_parameterUtils = __commonJS({
         }
       });
       result.paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
-      result.firstPositionOrKeywordIndex = result.params.findIndex((p) => p.kind !== ParamKind.Positional);
+      result.firstPositionOrKeywordIndex = result.params.findIndex((p) => p.kind !== ParamKind.Positional && p.kind !== ParamKind.ExpandedArgs);
       if (result.firstPositionOrKeywordIndex < 0) {
         result.firstPositionOrKeywordIndex = result.params.length;
       }
@@ -55082,6 +55213,60 @@ var require_parameterUtils = __commonJS({
       });
       return isCompatible;
     }
+    var ParamAssignmentTracker = class {
+      constructor(paramInfos) {
+        this.params = paramInfos.map((p) => {
+          const argsNeeded = !!p.defaultType || p.param.category !== 0 ? 0 : 1;
+          return { paramDetails: p, argsNeeded, argsReceived: 0 };
+        });
+      }
+      // Add a virtual keyword parameter for a keyword argument that
+      // targets a **kwargs parameter. This allows us to detect duplicate
+      // keyword arguments.
+      addKeywordParam(name, info) {
+        this.params.push({
+          paramDetails: info,
+          keywordName: name,
+          argsNeeded: 1,
+          argsReceived: 1
+        });
+      }
+      lookupName(name) {
+        return this.params.find((p) => {
+          const kind = p.paramDetails.kind;
+          if (kind === ParamKind.Positional || kind === ParamKind.ExpandedArgs) {
+            return false;
+          }
+          const effectiveName = p.keywordName ?? p.paramDetails.param.name;
+          return effectiveName === name;
+        });
+      }
+      lookupDetails(paramInfo) {
+        const info = this.params.find((p) => p.paramDetails === paramInfo);
+        (0, debug_1.assert)(info !== void 0);
+        return info;
+      }
+      markArgReceived(paramInfo) {
+        const entry = this.lookupDetails(paramInfo);
+        entry.argsReceived++;
+      }
+      // Returns a list of params that have not received their
+      // required number of arguments.
+      getUnassignedParams() {
+        const unassignedParams = [];
+        this.params.forEach((p) => {
+          if (!p.paramDetails.param.name) {
+            return;
+          }
+          if (p.argsReceived >= p.argsNeeded) {
+            return;
+          }
+          unassignedParams.push(p.paramDetails.param.name);
+        });
+        return unassignedParams;
+      }
+    };
+    exports2.ParamAssignmentTracker = ParamAssignmentTracker;
   }
 });
 
@@ -56521,7 +56706,7 @@ var require_constructorTransform = __commonJS({
       newParamList.forEach((param) => {
         types_1.FunctionType.addParam(newCallMemberType, param);
       });
-      newCallMemberType.shared.declaredReturnType = specializedFunctionType.shared.declaredReturnType ? types_1.FunctionType.getEffectiveReturnType(specializedFunctionType) : (_a = specializedFunctionType.priv.inferredReturnType) == null ? void 0 : _a.type;
+      newCallMemberType.shared.declaredReturnType = specializedFunctionType.shared.declaredReturnType ? types_1.FunctionType.getEffectiveReturnType(specializedFunctionType) : (_a = specializedFunctionType.shared.inferredReturnType) == null ? void 0 : _a.type;
       newCallMemberType.shared.declaration = partialCallMemberType.shared.declaration;
       newCallMemberType.shared.typeVarScopeId = specializedFunctionType.shared.typeVarScopeId;
       return { returnType: newCallMemberType, isTypeIncomplete: false, argumentErrors };
@@ -56829,7 +57014,7 @@ var require_constructors = __commonJS({
         0
         /* MemberAccessFlags.Default */
       )) == null ? void 0 : _a.type;
-      if (!newMethodType || !(0, types_1.isFunction)(newMethodType) && !(0, types_1.isOverloaded)(newMethodType)) {
+      if (!newMethodType || !(0, types_1.isFunctionOrOverloaded)(newMethodType)) {
         return { returnType: (0, typeUtils_1.convertToInstance)(type) };
       }
       return validateNewMethod(
@@ -56968,7 +57153,7 @@ var require_constructors = __commonJS({
         return void 0;
       }
       const callType = evaluator.getTypeOfMember(callInfo);
-      if (!(0, types_1.isFunction)(callType) && !(0, types_1.isOverloaded)(callType)) {
+      if (!(0, types_1.isFunctionOrOverloaded)(callType)) {
         return void 0;
       }
       const boundCallType = evaluator.bindFunctionToClassOrObject(
@@ -57185,7 +57370,7 @@ var require_constructors = __commonJS({
       return skipInitCheck;
     }
     function isDefaultNewMethod(newMethod) {
-      var _a;
+      var _a, _b;
       if (!newMethod || !(0, types_1.isFunction)(newMethod)) {
         return false;
       }
@@ -57196,7 +57381,12 @@ var require_constructors = __commonJS({
       if (params[0].category !== 1 || params[1].category !== 2) {
         return false;
       }
-      const returnType = newMethod.shared.declaredReturnType ?? ((_a = newMethod.priv.inferredReturnType) == null ? void 0 : _a.type);
+      let returnType;
+      if (newMethod.shared.declaredReturnType) {
+        returnType = newMethod.shared.declaredReturnType;
+      } else {
+        returnType = ((_a = newMethod.priv.specializedTypes) == null ? void 0 : _a.returnType) ?? ((_b = newMethod.shared.inferredReturnType) == null ? void 0 : _b.type);
+      }
       if (!returnType || !(0, types_1.isTypeVar)(returnType) || !types_1.TypeVarType.isSelf(returnType)) {
         return false;
       }
@@ -57346,6 +57536,10 @@ var require_namedTuples = __commonJS({
             entries.forEach((entryName, index) => {
               entryName = entryName.trim();
               if (entryName) {
+                if (entryName.startsWith("_")) {
+                  evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedTupleFieldUnderscore(), entriesArg.valueExpression);
+                  return;
+                }
                 entryName = renameKeyword(evaluator, entryName, allowRename, entriesArg.valueExpression, index);
                 const entryType = types_1.UnknownType.create();
                 const paramInfo = types_1.FunctionParam.create(0, entryType, types_1.FunctionParamFlags.TypeDeclared, entryName, index >= firstParamWithDefaultIndex ? entryType : void 0);
@@ -57396,6 +57590,10 @@ var require_namedTuples = __commonJS({
                   if (!entryName) {
                     evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedTupleEmptyName(), entryNameNode);
                   } else {
+                    if (entryName.startsWith("_")) {
+                      evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedTupleFieldUnderscore(), entryNameNode);
+                      return;
+                    }
                     entryName = renameKeyword(evaluator, entryName, allowRename, entryNameNode, index);
                   }
                 } else {
@@ -57715,7 +57913,7 @@ var require_dataClasses = __commonJS({
             }
             hasDefault = true;
             defaultExpr = statement.d.rightExpr;
-            if (statement.d.rightExpr.nodeType === 9) {
+            if (!isNamedTuple && statement.d.rightExpr.nodeType === 9) {
               const callTypeResult = evaluator.getTypeOfExpression(
                 statement.d.rightExpr.d.leftExpr,
                 2
@@ -57804,6 +58002,10 @@ var require_dataClasses = __commonJS({
           }
           if (variableNameNode && variableTypeEvaluator) {
             const variableName = variableNameNode.d.value;
+            if (isNamedTuple && variableName.startsWith("_")) {
+              evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedTupleFieldUnderscore(), variableNameNode);
+              return;
+            }
             const variableSymbol = types_1.ClassType.getSymbolTable(classType).get(variableName);
             namedTupleEntries.add(variableName);
             if (variableSymbol == null ? void 0 : variableSymbol.isClassVar()) {
@@ -57885,7 +58087,7 @@ var require_dataClasses = __commonJS({
           if (!statement || statement.nodeType !== 3) {
             return;
           }
-          if (statement.d.rightExpr.nodeType === 9) {
+          if (!isNamedTuple && statement.d.rightExpr.nodeType === 9) {
             const callType = evaluator.getTypeOfExpression(
               statement.d.rightExpr.d.leftExpr,
               2
@@ -58105,7 +58307,7 @@ var require_dataClasses = __commonJS({
       targetFunction.shared.declaredReturnType = fieldType;
       types_1.FunctionType.addParam(targetFunction, types_1.FunctionParam.create(0, typeVar, types_1.FunctionParamFlags.TypeDeclared | types_1.FunctionParamFlags.NameSynthesized, "__input"));
       types_1.FunctionType.addPositionOnlyParamSeparator(targetFunction);
-      if ((0, types_1.isFunction)(converterType) || (0, types_1.isOverloaded)(converterType)) {
+      if ((0, types_1.isFunctionOrOverloaded)(converterType)) {
         const acceptedTypes = [];
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         (0, typeUtils_1.doForEachSignature)(converterType, (signature) => {
@@ -58151,7 +58353,7 @@ var require_dataClasses = __commonJS({
       return fieldType;
     }
     function getConverterAsFunction(evaluator, converterType) {
-      if ((0, types_1.isFunction)(converterType) || (0, types_1.isOverloaded)(converterType)) {
+      if ((0, types_1.isFunctionOrOverloaded)(converterType)) {
         return converterType;
       }
       if ((0, types_1.isClassInstance)(converterType)) {
@@ -58163,7 +58365,7 @@ var require_dataClasses = __commonJS({
           if ((0, types_1.isUnion)(fromConstructor)) {
             fromConstructor = fromConstructor.priv.subtypes[0];
           }
-          if ((0, types_1.isFunction)(fromConstructor) || (0, types_1.isOverloaded)(fromConstructor)) {
+          if ((0, types_1.isFunctionOrOverloaded)(fromConstructor)) {
             return fromConstructor;
           }
         }
@@ -58347,7 +58549,7 @@ var require_dataClasses = __commonJS({
           case "field_descriptors":
           case "field_specifiers": {
             const valueType = evaluator.getTypeOfExpression(arg.d.valueExpr).type;
-            if (!(0, types_1.isClassInstance)(valueType) || !types_1.ClassType.isBuiltIn(valueType, "tuple") || !valueType.priv.tupleTypeArgs || valueType.priv.tupleTypeArgs.some((entry) => !(0, types_1.isInstantiableClass)(entry.type) && !(0, types_1.isFunction)(entry.type) && !(0, types_1.isOverloaded)(entry.type))) {
+            if (!(0, types_1.isClassInstance)(valueType) || !types_1.ClassType.isBuiltIn(valueType, "tuple") || !valueType.priv.tupleTypeArgs || valueType.priv.tupleTypeArgs.some((entry) => !(0, types_1.isInstantiableClass)(entry.type) && !(0, types_1.isFunctionOrOverloaded)(entry.type))) {
               evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformFieldSpecifier().format({
                 type: evaluator.printType(valueType)
               }), arg.d.valueExpr);
@@ -58935,12 +59137,12 @@ var require_typeGuards = __commonJS({
             if (leftExpression.nodeType === 4) {
               leftExpression = leftExpression.d.name;
             }
-            if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
+            if (ParseTreeUtils.isMatchingExpression(reference, leftExpression, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               return (type) => {
                 return { type: narrowTypeForIsNone(evaluator, type, adjIsPositiveTest), isIncomplete: false };
               };
             }
-            if (leftExpression.nodeType === 27 && ParseTreeUtils.isMatchingExpression(reference, leftExpression.d.leftExpr) && leftExpression.d.items.length === 1 && !leftExpression.d.trailingComma && leftExpression.d.items[0].d.argCategory === 0 && !leftExpression.d.items[0].d.name && leftExpression.d.items[0].d.valueExpr.nodeType === 40 && leftExpression.d.items[0].d.valueExpr.d.isInteger && !leftExpression.d.items[0].d.valueExpr.d.isImaginary) {
+            if (leftExpression.nodeType === 27 && ParseTreeUtils.isMatchingExpression(reference, leftExpression.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr)) && leftExpression.d.items.length === 1 && !leftExpression.d.trailingComma && leftExpression.d.items[0].d.argCategory === 0 && !leftExpression.d.items[0].d.name && leftExpression.d.items[0].d.valueExpr.nodeType === 40 && leftExpression.d.items[0].d.valueExpr.d.isInteger && !leftExpression.d.items[0].d.valueExpr.d.isImaginary) {
               const indexValue = leftExpression.d.items[0].d.valueExpr.d.value;
               if (typeof indexValue === "number") {
                 return (type) => {
@@ -58957,7 +59159,7 @@ var require_typeGuards = __commonJS({
             if (leftExpression.nodeType === 4) {
               leftExpression = leftExpression.d.name;
             }
-            if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
+            if (ParseTreeUtils.isMatchingExpression(reference, leftExpression, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               return (type) => {
                 return {
                   type: narrowTypeForIsEllipsis(evaluator, testExpression, type, adjIsPositiveTest),
@@ -58969,20 +59171,34 @@ var require_typeGuards = __commonJS({
           if (testExpression.d.leftExpr.nodeType === 9) {
             if (testExpression.d.leftExpr.d.args.length === 1 && testExpression.d.leftExpr.d.args[0].d.argCategory === 0) {
               const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
-              if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+              if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
                 const callType = evaluator.getTypeOfExpression(
                   testExpression.d.leftExpr.d.leftExpr,
                   2
                   /* EvalFlags.CallBaseDefaults */
                 ).type;
                 if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, "type")) {
-                  const classTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
-                  const classType = evaluator.makeTopLevelTypeVarsConcrete(classTypeResult.type);
-                  if ((0, types_1.isInstantiableClass)(classType)) {
+                  const rhsResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
+                  const classTypes = [];
+                  let isClassType = true;
+                  evaluator.mapSubtypesExpandTypeVars(
+                    rhsResult.type,
+                    /* options */
+                    void 0,
+                    (expandedSubtype) => {
+                      if ((0, types_1.isInstantiableClass)(expandedSubtype)) {
+                        classTypes.push(expandedSubtype);
+                      } else {
+                        isClassType = false;
+                      }
+                      return void 0;
+                    }
+                  );
+                  if (isClassType && classTypes.length > 0) {
                     return (type) => {
                       return {
-                        type: narrowTypeForTypeIs(evaluator, type, classType, adjIsPositiveTest),
-                        isIncomplete: !!classTypeResult.isIncomplete
+                        type: narrowTypeForTypeIs(evaluator, type, classTypes, adjIsPositiveTest),
+                        isIncomplete: !!rhsResult.isIncomplete
                       };
                     };
                   }
@@ -58991,7 +59207,7 @@ var require_typeGuards = __commonJS({
             }
           }
           if (isOrIsNotOperator) {
-            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
+            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
               const rightType = rightTypeResult.type;
               if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== void 0) {
@@ -59018,7 +59234,7 @@ var require_typeGuards = __commonJS({
                 };
               }
             }
-            if (testExpression.d.leftExpr.nodeType === 27 && testExpression.d.leftExpr.d.items.length === 1 && !testExpression.d.leftExpr.d.trailingComma && testExpression.d.leftExpr.d.items[0].d.argCategory === 0 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+            if (testExpression.d.leftExpr.nodeType === 27 && testExpression.d.leftExpr.d.items.length === 1 && !testExpression.d.leftExpr.d.trailingComma && testExpression.d.leftExpr.d.items[0].d.argCategory === 0 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               const indexTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
               const indexType = indexTypeResult.type;
               if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
@@ -59057,7 +59273,7 @@ var require_typeGuards = __commonJS({
           }
           if (equalsOrNotEqualsOperator) {
             const adjIsPositiveTest2 = testExpression.d.operator === 12 ? isPositiveTest : !isPositiveTest;
-            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
+            if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
               const rightType = rightTypeResult.type;
               if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== void 0) {
@@ -59076,7 +59292,7 @@ var require_typeGuards = __commonJS({
                 };
               }
             }
-            if (testExpression.d.leftExpr.nodeType === 27 && testExpression.d.leftExpr.d.items.length === 1 && !testExpression.d.leftExpr.d.trailingComma && testExpression.d.leftExpr.d.items[0].d.argCategory === 0 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+            if (testExpression.d.leftExpr.nodeType === 27 && testExpression.d.leftExpr.d.items.length === 1 && !testExpression.d.leftExpr.d.trailingComma && testExpression.d.leftExpr.d.items[0].d.argCategory === 0 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
               const indexTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
               const indexType = indexTypeResult.type;
               if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
@@ -59101,7 +59317,7 @@ var require_typeGuards = __commonJS({
               }
             }
           }
-          if (equalsOrNotEqualsOperator && testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+          if (equalsOrNotEqualsOperator && testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
             const rightType = rightTypeResult.type;
             const memberName = testExpression.d.leftExpr.d.member;
@@ -59116,7 +59332,7 @@ var require_typeGuards = __commonJS({
               }
             }
           }
-          if (testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
+          if (testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
             const rightType = rightTypeResult.type;
             const memberName = testExpression.d.leftExpr.d.member;
@@ -59129,7 +59345,7 @@ var require_typeGuards = __commonJS({
               };
             }
           }
-          if (testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr) && testExpression.d.rightExpr.nodeType === 14 && testExpression.d.rightExpr.d.constType === 26) {
+          if (testExpression.d.leftExpr.nodeType === 35 && ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr)) && testExpression.d.rightExpr.nodeType === 14 && testExpression.d.rightExpr.d.constType === 26) {
             const memberName = testExpression.d.leftExpr.d.member;
             return (type) => {
               return {
@@ -59141,7 +59357,7 @@ var require_typeGuards = __commonJS({
         }
         if (comparisonOperator && testExpression.d.leftExpr.nodeType === 9 && testExpression.d.leftExpr.d.args.length === 1) {
           const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
-          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const callTypeResult = evaluator.getTypeOfExpression(
               testExpression.d.leftExpr.d.leftExpr,
               2
@@ -59170,7 +59386,7 @@ var require_typeGuards = __commonJS({
           }
         }
         if (testExpression.d.operator === 41 || testExpression.d.operator === 42) {
-          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
             const rightType = rightTypeResult.type;
             const adjIsPositiveTest = testExpression.d.operator === 41 ? isPositiveTest : !isPositiveTest;
@@ -59181,7 +59397,7 @@ var require_typeGuards = __commonJS({
               };
             };
           }
-          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.rightExpr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.rightExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const leftTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr);
             const leftType = leftTypeResult.type;
             if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, "str") && (0, typeUtils_1.isLiteralType)(leftType)) {
@@ -59200,7 +59416,7 @@ var require_typeGuards = __commonJS({
         if (testExpression.d.args.length === 2) {
           const arg0Expr = testExpression.d.args[0].d.valueExpr;
           const arg1Expr = testExpression.d.args[1].d.valueExpr;
-          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const callTypeResult = evaluator.getTypeOfExpression(
               testExpression.d.leftExpr,
               2
@@ -59245,7 +59461,7 @@ var require_typeGuards = __commonJS({
           }
         }
         if (testExpression.d.args.length === 1 && !testExpression.d.args[0].d.name) {
-          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.args[0].d.valueExpr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.args[0].d.valueExpr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             const callTypeResult = evaluator.getTypeOfExpression(
               testExpression.d.leftExpr,
               2
@@ -59264,7 +59480,7 @@ var require_typeGuards = __commonJS({
         }
         if (testExpression.d.args.length >= 1) {
           const arg0Expr = testExpression.d.args[0].d.valueExpr;
-          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
+          if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
             let isPossiblyTypeGuard = false;
             const isFunctionReturnTypeGuard = (type) => {
               return type.shared.declaredReturnType && (0, types_1.isClassInstance)(type.shared.declaredReturnType) && types_1.ClassType.isBuiltIn(type.shared.declaredReturnType, ["TypeGuard", "TypeIs"]);
@@ -59300,7 +59516,7 @@ var require_typeGuards = __commonJS({
           }
         }
       }
-      if (ParseTreeUtils.isMatchingExpression(reference, testExpression)) {
+      if (ParseTreeUtils.isMatchingExpression(reference, testExpression, (ref, expr) => isNameSameScope(evaluator, ref, expr))) {
         return (type) => {
           return {
             type: narrowTypeForTruthiness(evaluator, type, isPositiveTest),
@@ -59895,8 +60111,23 @@ var require_typeGuards = __commonJS({
               } else {
                 filteredTypes.push((0, typeUtils_1.convertToInstance)(filterType));
               }
-            } else if (evaluator.assignType((0, typeUtils_1.convertToInstance)(convertVarTypeToFree(concreteFilterType)), varType)) {
-              filteredTypes.push((0, typeUtils_1.convertToInstance)(varType));
+            } else {
+              const filterTypeInstance = (0, typeUtils_1.convertToInstance)(convertVarTypeToFree(concreteFilterType));
+              if (evaluator.assignType(filterTypeInstance, varType)) {
+                filteredTypes.push((0, typeUtils_1.convertToInstance)(varType));
+              } else {
+                if ((0, types_1.isClassInstance)(filterTypeInstance) && !types_1.ClassType.isFinal(filterTypeInstance)) {
+                  const gradualFunc = types_1.FunctionType.createSynthesizedInstance(
+                    "",
+                    32768
+                    /* FunctionTypeFlags.GradualCallableForm */
+                  );
+                  types_1.FunctionType.addDefaultParams(gradualFunc);
+                  if (!evaluator.assignType(gradualFunc, filterTypeInstance)) {
+                    filteredTypes.push((0, typeUtils_1.convertToInstance)(filterType));
+                  }
+                }
+              }
             }
           }
         } else {
@@ -59953,7 +60184,7 @@ var require_typeGuards = __commonJS({
         if ((0, types_1.isClass)(subtype)) {
           return (0, types_1.combineTypes)(filterClassType(unexpandedSubtype, types_1.ClassType.cloneAsInstantiable(subtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
         }
-        if ((0, types_1.isFunction)(subtype) || (0, types_1.isOverloaded)(subtype)) {
+        if ((0, types_1.isFunctionOrOverloaded)(subtype)) {
           return (0, types_1.combineTypes)(filterFunctionType(subtype, unexpandedSubtype));
         }
         return isPositiveTest ? void 0 : negativeFallback;
@@ -60136,10 +60367,10 @@ var require_typeGuards = __commonJS({
             if (!evaluator.isTypeComparable(elementSubtype, referenceSubtype)) {
               return void 0;
             }
-            if ((0, types_1.isClassInstance)(elementSubtype) && ((0, typeUtils_1.isLiteralType)(elementSubtype) || (0, typeUtils_1.isNoneInstance)(elementSubtype)) && evaluator.assignType(referenceSubtype, elementSubtype)) {
+            if ((0, types_1.isClassInstance)(elementSubtype) && ((0, typeUtils_1.isLiteralLikeType)(elementSubtype) || (0, typeUtils_1.isNoneInstance)(elementSubtype)) && evaluator.assignType(referenceSubtype, elementSubtype)) {
               return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(elementSubtype, (_a = referenceSubtype.props) == null ? void 0 : _a.condition));
             }
-            if ((0, types_1.isClassInstance)(referenceSubtype) && ((0, typeUtils_1.isLiteralType)(referenceSubtype) || (0, typeUtils_1.isNoneInstance)(referenceSubtype)) && evaluator.assignType(elementSubtype, referenceSubtype)) {
+            if ((0, types_1.isClassInstance)(referenceSubtype) && ((0, typeUtils_1.isLiteralLikeType)(referenceSubtype) || (0, typeUtils_1.isNoneInstance)(referenceSubtype)) && evaluator.assignType(elementSubtype, referenceSubtype)) {
               return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(referenceSubtype, (_b = elementSubtype.props) == null ? void 0 : _b.condition));
             }
             if ((0, types_1.isInstantiableClass)(elementSubtype) && !elementSubtype.priv.includeSubclasses && evaluator.assignType(referenceSubtype, elementSubtype)) {
@@ -60311,37 +60542,48 @@ var require_typeGuards = __commonJS({
         return subtype;
       });
     }
-    function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
-      return evaluator.mapSubtypesExpandTypeVars(
-        type,
-        /* options */
-        void 0,
-        (subtype, unexpandedSubtype) => {
-          var _a;
-          if ((0, types_1.isClassInstance)(subtype)) {
-            const matches = types_1.ClassType.isDerivedFrom(classType, types_1.ClassType.cloneAsInstantiable(subtype));
-            if (isPositiveTest) {
-              if (matches) {
-                if (types_1.ClassType.isSameGenericClass(types_1.ClassType.cloneAsInstantiable(subtype), classType)) {
-                  return (0, typeUtils_1.addConditionToType)(subtype, (0, typeUtils_1.getTypeCondition)(classType));
+    function narrowTypeForTypeIs(evaluator, type, classTypes, isPositiveTest) {
+      if (!isPositiveTest && classTypes.length > 1) {
+        return type;
+      }
+      const typesToCombine = classTypes.map((classType) => {
+        return evaluator.mapSubtypesExpandTypeVars(
+          type,
+          /* options */
+          void 0,
+          (subtype, unexpandedSubtype) => {
+            var _a, _b;
+            if ((0, types_1.isClassInstance)(subtype)) {
+              const matches = types_1.ClassType.isDerivedFrom(classType, types_1.ClassType.cloneAsInstantiable(subtype));
+              if (isPositiveTest) {
+                if (matches) {
+                  if (types_1.ClassType.isSameGenericClass(types_1.ClassType.cloneAsInstantiable(subtype), classType)) {
+                    return (0, typeUtils_1.addConditionToType)(subtype, (0, typeUtils_1.getTypeCondition)(classType));
+                  }
+                  return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), (_a = subtype.props) == null ? void 0 : _a.condition);
+                }
+                if (!classType.priv.includeSubclasses) {
+                  return void 0;
+                }
+                if (!(0, types_1.isTypeVar)(unexpandedSubtype) || !types_1.TypeVarType.isSelf(unexpandedSubtype)) {
+                  return (0, typeUtils_1.addConditionToType)(subtype, (_b = classType.props) == null ? void 0 : _b.condition);
                 }
-                return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), (_a = subtype.props) == null ? void 0 : _a.condition);
               }
               if (!classType.priv.includeSubclasses) {
-                return void 0;
-              }
-            } else if (!classType.priv.includeSubclasses) {
-              if (matches && types_1.ClassType.isFinal(subtype)) {
-                return void 0;
+                if (matches && types_1.ClassType.isFinal(subtype)) {
+                  return void 0;
+                }
+                return subtype;
               }
-              return subtype;
             }
-          } else if ((0, types_1.isAnyOrUnknown)(subtype)) {
-            return isPositiveTest ? types_1.ClassType.cloneAsInstance((0, typeUtils_1.addConditionToType)(classType, (0, typeUtils_1.getTypeCondition)(subtype))) : subtype;
+            if ((0, types_1.isAnyOrUnknown)(subtype)) {
+              return isPositiveTest ? types_1.ClassType.cloneAsInstance((0, typeUtils_1.addConditionToType)(classType, (0, typeUtils_1.getTypeCondition)(subtype))) : subtype;
+            }
+            return unexpandedSubtype;
           }
-          return unexpandedSubtype;
-        }
-      );
+        );
+      });
+      return (0, types_1.combineTypes)(typesToCombine);
     }
     function narrowTypeForClassComparison(evaluator, referenceType, classType, isPositiveTest) {
       return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
@@ -60410,24 +60652,29 @@ var require_typeGuards = __commonJS({
               return literalType;
             }
             return subtype;
-          } else if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(literalType, subtype)) {
+          }
+          if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(literalType, subtype)) {
             if (subtype.priv.literalValue !== void 0) {
               const literalValueMatches = types_1.ClassType.isLiteralValueSame(subtype, literalType);
               if (isPositiveTest) {
                 return literalValueMatches ? subtype : void 0;
-              } else {
-                const isEnumOrBool = types_1.ClassType.isEnumClass(literalType) || types_1.ClassType.isBuiltIn(literalType, "bool");
-                return literalValueMatches && (isEnumOrBool || !isIsOperator) ? void 0 : subtype;
               }
-            } else if (isPositiveTest) {
+              const isEnumOrBool = types_1.ClassType.isEnumClass(literalType) || types_1.ClassType.isBuiltIn(literalType, "bool");
+              return literalValueMatches && (isEnumOrBool || !isIsOperator) ? void 0 : subtype;
+            }
+            if (isPositiveTest) {
+              return literalType;
+            }
+            const allLiteralTypes = enumerateLiteralsForType(evaluator, subtype);
+            if (allLiteralTypes && allLiteralTypes.length > 0) {
+              return (0, types_1.combineTypes)(allLiteralTypes.filter((type) => !types_1.ClassType.isLiteralValueSame(type, literalType)));
+            }
+            return subtype;
+          }
+          if (isPositiveTest) {
+            if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, "LiteralString")) {
               return literalType;
-            } else {
-              const allLiteralTypes = enumerateLiteralsForType(evaluator, subtype);
-              if (allLiteralTypes && allLiteralTypes.length > 0) {
-                return (0, types_1.combineTypes)(allLiteralTypes.filter((type) => !types_1.ClassType.isLiteralValueSame(type, literalType)));
-              }
             }
-          } else if (isPositiveTest) {
             if (isIsOperator || (0, typeUtils_1.isNoneInstance)(subtype)) {
               const isSubtype = evaluator.assignType(subtype, literalType);
               return isSubtype ? literalType : void 0;
@@ -60471,6 +60718,29 @@ var require_typeGuards = __commonJS({
       }
       return void 0;
     }
+    function isNameSameScope(evaluator, reference, expression) {
+      const refSymbol = evaluator.lookUpSymbolRecursive(
+        reference,
+        reference.d.value,
+        /* honorCodeFlow */
+        false
+      );
+      const exprSymbol = evaluator.lookUpSymbolRecursive(
+        expression,
+        expression.d.value,
+        /* honorCodeFlow */
+        false
+      );
+      if (!refSymbol || !exprSymbol) {
+        return true;
+      }
+      const refScope = refSymbol.scope;
+      const exprScope = exprSymbol.scope;
+      if (refScope === exprScope) {
+        return true;
+      }
+      return (0, scopeUtils_1.isScopeContainedWithin)(refScope, exprScope);
+    }
   }
 });
 
@@ -60737,7 +61007,7 @@ var require_enums = __commonJS({
         if ((0, symbolNameUtils_1.isPrivateName)(memberName)) {
           return void 0;
         }
-        if (!(0, types_1.findSubtype)(valueType, (subtype) => !(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloaded)(subtype))) {
+        if (!(0, types_1.findSubtype)(valueType, (subtype) => !(0, types_1.isFunctionOrOverloaded)(subtype))) {
           return void 0;
         }
         if (!assignedType && ((_f = nameNode.parent) == null ? void 0 : _f.nodeType) === 3 && nameNode.parent.d.leftExpr === nameNode) {
@@ -61595,7 +61865,7 @@ var require_importResolver = __commonJS({
       return result;
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ImportResolver = exports2.supportedFileExtensions = void 0;
+    exports2.ImportResolver = exports2.supportedFileExtensions = exports2.supportedSourceFileExtensions = void 0;
     exports2.createImportedModuleDescriptor = createImportedModuleDescriptor;
     exports2.formatImportName = formatImportName;
     exports2.getParentImportResolutionRoot = getParentImportResolutionRoot;
@@ -61606,7 +61876,6 @@ var require_importResolver = __commonJS({
     var pathConsts_1 = require_pathConsts();
     var pathUtils_1 = require_pathUtils();
     var pythonVersion_1 = require_pythonVersion();
-    var serviceKeys_1 = require_serviceKeys();
     var StringUtils = __importStar(require_stringUtils());
     var stringUtils_1 = require_stringUtils();
     var uri_1 = require_uri();
@@ -61637,8 +61906,8 @@ var require_importResolver = __commonJS({
       };
     }
     var supportedNativeLibExtensions = [".pyd", ".so", ".dylib"];
-    var supportedSourceFileExtensions = [".py", ".pyi"];
-    exports2.supportedFileExtensions = [...supportedSourceFileExtensions, ...supportedNativeLibExtensions];
+    exports2.supportedSourceFileExtensions = [".py", ".pyi"];
+    exports2.supportedFileExtensions = [...exports2.supportedSourceFileExtensions, ...supportedNativeLibExtensions];
     var allowPartialResolutionForThirdPartyPackages = false;
     var ImportResolver = class _ImportResolver {
       constructor(serviceProvider, _configOptions, host) {
@@ -61659,11 +61928,11 @@ var require_importResolver = __commonJS({
         return this.serviceProvider.tmp();
       }
       get partialStubs() {
-        return this.serviceProvider.tryGet(serviceKeys_1.ServiceKeys.partialStubs);
+        return this.serviceProvider.partialStubs();
       }
       static isSupportedImportSourceFile(uri) {
         const fileExtension = uri.lastExtension.toLowerCase();
-        return supportedSourceFileExtensions.some((ext2) => fileExtension === ext2);
+        return exports2.supportedSourceFileExtensions.some((ext2) => fileExtension === ext2);
       }
       static isSupportedImportFile(uri) {
         const fileExtension = uri.lastExtension.toLowerCase();
@@ -64878,11 +65147,7 @@ var require_properties = __commonJS({
       propertyClass.priv.isAsymmetricDescriptor = false;
       updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
       propertyObject.priv.fgetInfo = {
-        methodType: types_1.FunctionType.cloneWithNewFlags(
-          fget,
-          fget.shared.flags | 4
-          /* FunctionTypeFlags.StaticMethod */
-        ),
+        methodType: fget,
         classType: fget.shared.methodClass
       };
       if (types_1.FunctionType.isClassMethod(fget)) {
@@ -64938,11 +65203,7 @@ var require_properties = __commonJS({
       });
       updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
       propertyObject.priv.fsetInfo = {
-        methodType: types_1.FunctionType.cloneWithNewFlags(
-          fset,
-          fset.shared.flags | 4
-          /* FunctionTypeFlags.StaticMethod */
-        ),
+        methodType: fset,
         classType: fset.shared.methodClass
       };
       addSetMethodToPropertySymbolTable(evaluator, propertyObject, fset);
@@ -64972,11 +65233,7 @@ var require_properties = __commonJS({
       });
       updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
       propertyObject.priv.fdelInfo = {
-        methodType: types_1.FunctionType.cloneWithNewFlags(
-          fdel,
-          fdel.shared.flags | 4
-          /* FunctionTypeFlags.StaticMethod */
-        ),
+        methodType: fdel,
         classType: fdel.shared.methodClass
       };
       addDelMethodToPropertySymbolTable(evaluator, propertyObject, fdel);
@@ -65117,7 +65374,7 @@ var require_properties = __commonJS({
       accessors.forEach((accessorInfo) => {
         let destAccessType = accessorInfo.getFunction(destPropertyType);
         if (destAccessType && (0, types_1.isFunction)(destAccessType)) {
-          let srcAccessType = accessorInfo.getFunction(srcPropertyType);
+          const srcAccessType = accessorInfo.getFunction(srcPropertyType);
           if (!srcAccessType || !(0, types_1.isFunction)(srcAccessType)) {
             diag == null ? void 0 : diag.addMessage(accessorInfo.missingDiagMsg());
             isAssignable = false;
@@ -65128,16 +65385,6 @@ var require_properties = __commonJS({
           if (selfSolution) {
             destAccessType = (0, typeUtils_1.applySolvedTypeVars)(destAccessType, selfSolution);
           }
-          destAccessType = types_1.FunctionType.cloneWithNewFlags(
-            destAccessType,
-            destAccessType.shared.flags & ~4
-            /* FunctionTypeFlags.StaticMethod */
-          );
-          srcAccessType = types_1.FunctionType.cloneWithNewFlags(
-            srcAccessType,
-            srcAccessType.shared.flags & ~4
-            /* FunctionTypeFlags.StaticMethod */
-          );
           const boundDestAccessType = evaluator.bindFunctionToClassOrObject(
             destObjectToBind,
             destAccessType,
@@ -65447,7 +65694,7 @@ var require_protocols = __commonJS({
             } else {
               srcMemberType = types_1.UnknownType.create();
             }
-            if ((0, types_1.isFunction)(srcMemberType) || (0, types_1.isOverloaded)(srcMemberType)) {
+            if ((0, types_1.isFunctionOrOverloaded)(srcMemberType)) {
               if (isMemberFromMetaclass || (0, types_1.isInstantiableClass)(srcMemberInfo.classType)) {
                 let isInstanceMember = !srcMemberInfo.symbol.isClassMember();
                 if (types_1.ClassType.isDataClass(srcType)) {
@@ -65492,7 +65739,7 @@ var require_protocols = __commonJS({
             srcMemberType = evaluator.getEffectiveTypeOfSymbol(srcSymbol);
           }
           destMemberType = (0, typeUtils_1.applySolvedTypeVars)(destMemberType, selfSolution);
-          if (!destSymbol.isInstanceMember() && ((0, types_1.isFunction)(destMemberType) || (0, types_1.isOverloaded)(destMemberType))) {
+          if (!destSymbol.isInstanceMember() && (0, types_1.isFunctionOrOverloaded)(destMemberType)) {
             let boundDeclaredType;
             isDestReadOnly = true;
             if ((0, types_1.isClass)(srcType)) {
@@ -67213,7 +67460,7 @@ var require_codeFlowEngine = __commonJS({
               }
               const newMethodResult = (0, constructors_1.getBoundNewMethod)(evaluator2, node, callSubtype);
               if (newMethodResult) {
-                if ((0, types_1.isFunction)(newMethodResult.type) || (0, types_1.isOverloaded)(newMethodResult.type)) {
+                if ((0, types_1.isFunctionOrOverloaded)(newMethodResult.type)) {
                   callSubtype = newMethodResult.type;
                 }
               }
@@ -68424,7 +68671,7 @@ var require_operations = __commonJS({
         }
         if (!type) {
           if (!isIncomplete) {
-            if (inferenceContext) {
+            if (inferenceContext && !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
               evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOperatorIssue, localize_1.LocMessage.typeNotSupportUnaryOperatorBidirectional().format({
                 operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
                 type: evaluator.printType(exprType),
@@ -68627,10 +68874,13 @@ var require_operations = __commonJS({
               } else if (operator === 13) {
                 if (rightLiteralValue !== BigInt(0)) {
                   newValue = leftLiteralValue / rightLiteralValue;
+                  if (newValue * rightLiteralValue !== leftLiteralValue && leftLiteralValue < BigInt(0) !== rightLiteralValue < BigInt(0)) {
+                    newValue -= BigInt(1);
+                  }
                 }
               } else if (operator === 24) {
                 if (rightLiteralValue !== BigInt(0)) {
-                  newValue = leftLiteralValue % rightLiteralValue;
+                  newValue = (leftLiteralValue % rightLiteralValue + rightLiteralValue) % rightLiteralValue;
                 }
               } else if (operator === 29) {
                 if (rightLiteralValue >= BigInt(0)) {
@@ -68640,9 +68890,13 @@ var require_operations = __commonJS({
                   }
                 }
               } else if (operator === 17) {
-                newValue = leftLiteralValue << rightLiteralValue;
+                if (rightLiteralValue >= BigInt(0)) {
+                  newValue = leftLiteralValue << rightLiteralValue;
+                }
               } else if (operator === 31) {
-                newValue = leftLiteralValue >> rightLiteralValue;
+                if (rightLiteralValue >= BigInt(0)) {
+                  newValue = leftLiteralValue >> rightLiteralValue;
+                }
               } else if (operator === 3) {
                 newValue = leftLiteralValue & rightLiteralValue;
               } else if (operator === 6) {
@@ -68698,7 +68952,7 @@ var require_operations = __commonJS({
       return true;
     }
     function convertFunctionToObject(evaluator, type) {
-      if ((0, types_1.isFunction)(type) || (0, types_1.isOverloaded)(type)) {
+      if ((0, types_1.isFunctionOrOverloaded)(type)) {
         return evaluator.getObjectType();
       }
       return type;
@@ -68813,7 +69067,7 @@ var require_operations = __commonJS({
               }
             }
             if (!resultTypeResult) {
-              if (inferenceContext) {
+              if (inferenceContext && !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
                 diag.addMessage(localize_1.LocMessage.typeNotSupportBinaryOperatorBidirectional().format({
                   operator: (0, parseTreeUtils_1.printOperator)(operator),
                   leftType: evaluator.printType(leftSubtypeExpanded),
@@ -68980,6 +69234,8 @@ var require_tuples = __commonJS({
         type = makeTupleObject(evaluator, evaluator.buildTupleTypesList(
           entryTypeResults,
           /* stripLiterals */
+          false,
+          /* convertModule */
           false
         ));
       }
@@ -68995,7 +69251,12 @@ var require_tuples = __commonJS({
       if (node.d.items.length > maxInferredTupleEntryCount) {
         return { type: makeTupleObject(evaluator, [{ type: types_1.UnknownType.create(), isUnbounded: true }]) };
       }
-      const type = makeTupleObject(evaluator, evaluator.buildTupleTypesList(entryTypeResults, (flags & 268435456) !== 0));
+      const type = makeTupleObject(evaluator, evaluator.buildTupleTypesList(
+        entryTypeResults,
+        (flags & 268435456) !== 0,
+        /* convertModule */
+        true
+      ));
       if (isIncomplete) {
         if ((0, typeUtils_1.getContainerDepth)(type) > typeEvaluatorTypes_1.maxInferredContainerDepth) {
           return { type: types_1.UnknownType.create() };
@@ -70390,6 +70651,7 @@ var require_typeEvaluator = __commonJS({
     exports2.createTypeEvaluator = createTypeEvaluator;
     var cancellationUtils_1 = require_cancellationUtils();
     var collectionUtils_1 = require_collectionUtils();
+    var core_1 = require_core();
     var debug_1 = require_debug();
     var diagnostic_1 = require_diagnostic();
     var diagnosticRules_1 = require_diagnosticRules();
@@ -70434,7 +70696,6 @@ var require_typeEvaluator = __commonJS({
     var TypePrinter = __importStar(require_typePrinter());
     var types_1 = require_types();
     var typeUtils_1 = require_typeUtils();
-    var core_1 = require_core();
     var nonSubscriptableBuiltinTypes = /* @__PURE__ */ new Map([
       ["asyncio.futures.Future", pythonVersion_1.pythonVersion3_9],
       ["asyncio.tasks.Task", pythonVersion_1.pythonVersion3_9],
@@ -70463,6 +70724,7 @@ var require_typeEvaluator = __commonJS({
     var maxReturnCallSiteTypeInferenceCodeFlowComplexity = 8;
     var maxCallSiteReturnTypeCacheSize = 8;
     var maxEntriesToUseForInference = 64;
+    var maxReturnTypeInferenceAttempts = 8;
     var maxDeclarationsToUseForInference = 64;
     var maxEffectiveTypeEvaluationAttempts = 16;
     var maxTotalOverloadArgTypeExpansionCount = 256;
@@ -70487,7 +70749,7 @@ var require_typeEvaluator = __commonJS({
       let deferredClassCompletions = [];
       let cancellationToken;
       let printExpressionSpaceCount = 0;
-      let incompleteGenerationCount = 0;
+      let incompleteGenCount = 0;
       const returnTypeInferenceContextStack = [];
       let returnTypeInferenceTypeCache;
       const signatureTrackerStack = [];
@@ -70537,7 +70799,7 @@ var require_typeEvaluator = __commonJS({
         if (!cacheEntry) {
           return false;
         }
-        return !cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount;
+        return !cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenCount === incompleteGenCount;
       }
       function readTypeCache(node, flags) {
         var _a;
@@ -70565,18 +70827,18 @@ var require_typeEvaluator = __commonJS({
       function writeTypeCache(node, typeResult, flags, inferenceContext, allowSpeculativeCaching = false) {
         const typeCacheToUse = returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node) ? returnTypeInferenceTypeCache : typeCache;
         if (!typeResult.isIncomplete) {
-          incompleteGenerationCount++;
+          incompleteGenCount++;
         } else {
           const oldValue = typeCacheToUse.get(node.id);
           if (oldValue !== void 0 && !(0, types_1.isTypeSame)(typeResult.type, oldValue.typeResult.type)) {
-            incompleteGenerationCount++;
+            incompleteGenCount++;
           }
         }
-        typeCacheToUse.set(node.id, { typeResult, flags, incompleteGenerationCount });
+        typeCacheToUse.set(node.id, { typeResult, flags, incompleteGenCount });
         if (isSpeculativeModeInUse(node)) {
           speculativeTypeTracker.trackEntry(typeCacheToUse, node.id);
           if (allowSpeculativeCaching) {
-            speculativeTypeTracker.addSpeculativeType(node, typeResult, incompleteGenerationCount, inferenceContext == null ? void 0 : inferenceContext.expectedType);
+            speculativeTypeTracker.addSpeculativeType(node, typeResult, incompleteGenCount, inferenceContext == null ? void 0 : inferenceContext.expectedType);
           }
         }
       }
@@ -70790,18 +71052,21 @@ var require_typeEvaluator = __commonJS({
       }
       function getTypeOfExpression(node, flags = 0, inferenceContext) {
         const cacheEntry = readTypeCacheEntry(node);
-        if (cacheEntry && (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount)) {
-          if (printExpressionTypes) {
-            console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? " Errors" : ""}`);
+        if (cacheEntry) {
+          if (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenCount === incompleteGenCount) {
+            if (printExpressionTypes) {
+              console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? " Errors" : ""}`);
+            }
+            return cacheEntry.typeResult;
           }
-          return cacheEntry.typeResult;
-        } else {
-          const cacheEntry2 = speculativeTypeTracker.getSpeculativeType(node, inferenceContext == null ? void 0 : inferenceContext.expectedType);
-          if (cacheEntry2 && (!cacheEntry2.typeResult.isIncomplete || cacheEntry2.incompleteGenerationCount === incompleteGenerationCount)) {
+        }
+        const specCacheEntry = speculativeTypeTracker.getSpeculativeType(node, inferenceContext == null ? void 0 : inferenceContext.expectedType);
+        if (specCacheEntry) {
+          if (!specCacheEntry.typeResult.isIncomplete || specCacheEntry.incompleteGenerationCount === incompleteGenCount) {
             if (printExpressionTypes) {
-              console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(cacheEntry2.typeResult.type)}`);
+              console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(specCacheEntry.typeResult.type)}`);
             }
-            return cacheEntry2.typeResult;
+            return specCacheEntry.typeResult;
           }
         }
         if (printExpressionTypes) {
@@ -71083,9 +71348,10 @@ var require_typeEvaluator = __commonJS({
           false
         ) : void 0;
         const exprTypeResult = getTypeOfExpression(node.d.expr, flags, (0, typeUtils_1.makeInferenceContext)(expectedType));
+        const awaitableResult = getTypeOfAwaitable(exprTypeResult, node.d.expr);
         const typeResult = {
-          type: getTypeOfAwaitable(exprTypeResult.type, node.d.expr),
-          isIncomplete: exprTypeResult.isIncomplete,
+          type: awaitableResult.type,
+          isIncomplete: exprTypeResult.isIncomplete || awaitableResult.isIncomplete,
           typeErrors: exprTypeResult.typeErrors
         };
         if (exprTypeResult.isIncomplete) {
@@ -71718,7 +71984,7 @@ var require_typeEvaluator = __commonJS({
         if (!boundMethodResult || boundMethodResult.typeErrors) {
           return void 0;
         }
-        if ((0, types_1.isFunction)(boundMethodResult.type) || (0, types_1.isOverloaded)(boundMethodResult.type)) {
+        if ((0, types_1.isFunctionOrOverloaded)(boundMethodResult.type)) {
           return boundMethodResult.type;
         }
         if ((0, types_1.isClassInstance)(boundMethodResult.type)) {
@@ -71818,7 +72084,7 @@ var require_typeEvaluator = __commonJS({
                 const constructorType = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, subtype);
                 if (constructorType) {
                   (0, typeUtils_1.doForEachSubtype)(constructorType, (subtype2) => {
-                    if ((0, types_1.isFunction)(subtype2) || (0, types_1.isOverloaded)(subtype2)) {
+                    if ((0, types_1.isFunctionOrOverloaded)(subtype2)) {
                       addFunctionToSignature(subtype2);
                     }
                   });
@@ -71943,29 +72209,36 @@ var require_typeEvaluator = __commonJS({
             ).type;
             const baseTypeConcrete = makeTopLevelTypeVarsConcrete(baseType);
             let classMemberInfo;
-            if ((0, types_1.isClassInstance)(baseTypeConcrete)) {
-              classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(
-                baseTypeConcrete,
-                expression.d.member.d.value,
-                64
-                /* MemberAccessFlags.DeclaredTypesOnly */
-              );
-              classOrObjectBase = baseTypeConcrete;
-              memberAccessClass = classMemberInfo == null ? void 0 : classMemberInfo.classType;
-              if (classMemberInfo == null ? void 0 : classMemberInfo.isInstanceMember) {
-                bindFunction = false;
-              }
-              useDescriptorSetterType = true;
-            } else if ((0, types_1.isInstantiableClass)(baseTypeConcrete)) {
-              classMemberInfo = (0, typeUtils_1.lookUpClassMember)(
-                baseTypeConcrete,
-                expression.d.member.d.value,
-                16 | 64
-                /* MemberAccessFlags.DeclaredTypesOnly */
-              );
-              classOrObjectBase = baseTypeConcrete;
-              memberAccessClass = classMemberInfo == null ? void 0 : classMemberInfo.classType;
-            }
+            (0, typeUtils_1.doForEachSubtype)(
+              baseTypeConcrete,
+              (baseSubtype) => {
+                if ((0, types_1.isClassInstance)(baseSubtype)) {
+                  classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(
+                    baseSubtype,
+                    expression.d.member.d.value,
+                    64
+                    /* MemberAccessFlags.DeclaredTypesOnly */
+                  );
+                  classOrObjectBase = baseSubtype;
+                  memberAccessClass = classMemberInfo == null ? void 0 : classMemberInfo.classType;
+                  if (classMemberInfo == null ? void 0 : classMemberInfo.isInstanceMember) {
+                    bindFunction = false;
+                  }
+                  useDescriptorSetterType = true;
+                } else if ((0, types_1.isInstantiableClass)(baseSubtype)) {
+                  classMemberInfo = (0, typeUtils_1.lookUpClassMember)(
+                    baseSubtype,
+                    expression.d.member.d.value,
+                    16 | 64
+                    /* MemberAccessFlags.DeclaredTypesOnly */
+                  );
+                  classOrObjectBase = baseSubtype;
+                  memberAccessClass = classMemberInfo == null ? void 0 : classMemberInfo.classType;
+                }
+              },
+              /* sortSubtypes */
+              true
+            );
             if ((0, types_1.isTypeVar)(baseType)) {
               selfType = baseType;
             }
@@ -72032,7 +72305,7 @@ var require_typeEvaluator = __commonJS({
               if (memberAccessClass && (0, types_1.isInstantiableClass)(memberAccessClass)) {
                 declaredType = (0, typeUtils_1.partiallySpecializeType)(declaredType, memberAccessClass, getTypeClassType(), selfType);
               }
-              if ((0, types_1.isFunction)(declaredType) || (0, types_1.isOverloaded)(declaredType)) {
+              if ((0, types_1.isFunctionOrOverloaded)(declaredType)) {
                 if (bindFunction) {
                   declaredType = bindFunctionToClassOrObject(
                     classOrObjectBase,
@@ -72051,12 +72324,13 @@ var require_typeEvaluator = __commonJS({
         }
         return void 0;
       }
-      function getTypeOfAwaitable(type, errorNode) {
+      function getTypeOfAwaitable(typeResult, errorNode) {
         if (!(prefetched == null ? void 0 : prefetched.awaitableClass) || !(0, types_1.isInstantiableClass)(prefetched.awaitableClass) || prefetched.awaitableClass.shared.typeParams.length !== 1) {
-          return types_1.UnknownType.create();
+          return { type: types_1.UnknownType.create(), isIncomplete: typeResult.isIncomplete };
         }
         const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(prefetched.awaitableClass);
-        return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        const isIncomplete = !!typeResult.isIncomplete;
+        const type = (0, typeUtils_1.mapSubtypes)(typeResult.type, (subtype) => {
           subtype = makeTopLevelTypeVarsConcrete(subtype);
           if ((0, types_1.isAnyOrUnknown)(subtype)) {
             return subtype;
@@ -72072,16 +72346,18 @@ var require_typeEvaluator = __commonJS({
               return types_1.UnknownType.create();
             }
           }
-          if (errorNode) {
+          if (errorNode && !typeResult.isIncomplete) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotAwaitable().format({ type: printType(subtype) }) + (diag == null ? void 0 : diag.getString()), errorNode);
           }
           return types_1.UnknownType.create();
         });
+        return { type, isIncomplete };
       }
       function getTypeOfIterator(typeResult, isAsync, errorNode, emitNotIterableError = true) {
         const iterMethodName = isAsync ? "__aiter__" : "__iter__";
         const nextMethodName = isAsync ? "__anext__" : "__next__";
         let isValidIterator = true;
+        let isIncomplete = typeResult.isIncomplete;
         let type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(typeResult.type);
         type = makeTopLevelTypeVarsConcrete(type);
         type = (0, types_1.removeUnbound)(type);
@@ -72142,7 +72418,11 @@ var require_typeEvaluator = __commonJS({
                     if (!isAsync) {
                       return nextReturnType;
                     }
-                    return getTypeOfAwaitable(nextReturnType, errorNode);
+                    const awaitableResult = getTypeOfAwaitable({ type: nextReturnType, isIncomplete: typeResult.isIncomplete }, errorNode);
+                    if (awaitableResult.isIncomplete) {
+                      isIncomplete = true;
+                    }
+                    return awaitableResult.type;
                   }
                   return void 0;
                 }
@@ -72153,13 +72433,13 @@ var require_typeEvaluator = __commonJS({
               diag.addAddendum(iterReturnTypeDiag);
             }
           }
-          if (!typeResult.isIncomplete && emitNotIterableError) {
+          if (!isIncomplete && emitNotIterableError) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotIterable().format({ type: printType(subtype) }) + diag.getString(), errorNode);
           }
           isValidIterator = false;
           return void 0;
         });
-        return isValidIterator ? { type: iterableType, isIncomplete: typeResult.isIncomplete } : void 0;
+        return isValidIterator ? { type: iterableType, isIncomplete } : void 0;
       }
       function getTypeOfIterable(typeResult, isAsync, errorNode, emitNotIterableError = true) {
         const iterMethodName = isAsync ? "__aiter__" : "__iter__";
@@ -72519,7 +72799,7 @@ var require_typeEvaluator = __commonJS({
             }
             destType = declaredType;
           } else {
-            destType = narrowTypeBasedOnAssignment(nameNode, declaredType, typeResult).type;
+            destType = narrowTypeBasedOnAssignment(declaredType, typeResult).type;
           }
         } else {
           const scope = ScopeUtils.getScopeForNode(nameNode);
@@ -72548,7 +72828,7 @@ var require_typeEvaluator = __commonJS({
           }
         }
         if (!typeResult.isIncomplete) {
-          reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, destType, nameNode, ignoreEmptyContainers);
+          reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, typeResult.type, nameNode, ignoreEmptyContainers);
         }
         writeTypeCache(
           nameNode,
@@ -73095,26 +73375,11 @@ var require_typeEvaluator = __commonJS({
             break;
           }
           case 54: {
-            let annotationType = getTypeOfAnnotation(target.d.annotation, {
+            getTypeOfAnnotation(target.d.annotation, {
               varTypeAnnotation: true,
               allowFinal: isFinalAllowedForAssignmentTarget(target.d.valueExpr),
               allowClassVar: isClassVarAllowedForAssignmentTarget(target.d.valueExpr)
             });
-            if (annotationType) {
-              const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(target);
-              annotationType = (0, typeUtils_1.makeTypeVarsBound)(annotationType, liveScopeIds);
-            }
-            const isBareFinalOrClassVar = (0, types_1.isClassInstance)(annotationType) && (types_1.ClassType.isBuiltIn(annotationType, "Final") || types_1.ClassType.isBuiltIn(annotationType, "ClassVar"));
-            if (!isBareFinalOrClassVar) {
-              const isTypeAliasAnnotation = (0, types_1.isClassInstance)(annotationType) && types_1.ClassType.isBuiltIn(annotationType, "TypeAlias");
-              if (!isTypeAliasAnnotation) {
-                if (assignType(annotationType, typeResult.type)) {
-                  if (!(0, types_1.isClassInstance)(typeResult.type) || !types_1.ClassType.isEnumClass(typeResult.type)) {
-                    typeResult = narrowTypeBasedOnAssignment(target, annotationType, typeResult);
-                  }
-                }
-              }
-            }
             assignTypeToExpression(target.d.valueExpr, typeResult, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
             break;
           }
@@ -74118,8 +74383,9 @@ var require_typeEvaluator = __commonJS({
                   if (isModuleGetAttrSupported) {
                     const getAttrTypeResult = getEffectiveTypeOfSymbolForUsage(getAttrSymbol);
                     if ((0, types_1.isFunction)(getAttrTypeResult.type)) {
-                      type = getEffectiveReturnType(getAttrTypeResult.type);
-                      if (getAttrTypeResult.isIncomplete) {
+                      const returnTypeResult = getEffectiveReturnTypeResult(getAttrTypeResult.type);
+                      type = returnTypeResult.type;
+                      if (getAttrTypeResult.isIncomplete || returnTypeResult.isIncomplete) {
                         isIncomplete = true;
                       }
                     }
@@ -74212,7 +74478,7 @@ var require_typeEvaluator = __commonJS({
             (0, debug_1.assertNever)(baseType);
         }
         if (!type) {
-          const isFunctionRule = (0, types_1.isFunction)(baseType) || (0, types_1.isOverloaded)(baseType) || (0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, "function");
+          const isFunctionRule = (0, types_1.isFunctionOrOverloaded)(baseType) || (0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, "function");
           if (!baseTypeResult.isIncomplete) {
             let diagMessage = localize_1.LocMessage.memberAccess();
             if (usage.method === "set") {
@@ -74220,7 +74486,7 @@ var require_typeEvaluator = __commonJS({
             } else if (usage.method === "del") {
               diagMessage = localize_1.LocMessage.memberDelete();
             }
-            if (usage.setExpectedTypeDiag) {
+            if (usage.setExpectedTypeDiag && !usage.setExpectedTypeDiag.isEmpty()) {
               diag = usage.setExpectedTypeDiag;
             }
             if ((0, types_1.isClass)(baseType) && baseType.shared.typedDictEntries) {
@@ -74382,7 +74648,7 @@ var require_typeEvaluator = __commonJS({
               isDescriptorApplied = true;
             }
             resultType = descResult.type;
-          } else if ((0, types_1.isFunction)(concreteSubtype) || (0, types_1.isOverloaded)(concreteSubtype)) {
+          } else if ((0, types_1.isFunctionOrOverloaded)(concreteSubtype) && types_1.TypeBase.isInstance(concreteSubtype)) {
             const typeResult = bindMethodForMemberAccess(subtype, concreteSubtype, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount);
             resultType = typeResult.type;
             if (typeResult.typeErrors) {
@@ -74411,10 +74677,10 @@ var require_typeEvaluator = __commonJS({
             isDescriptorError = true;
           }
           return resultType;
-        });
+        }, { retainTypeAlias: true });
         if (!isDescriptorError && usage.method === "set" && usage.setType) {
           if (errorNode && memberInfo.symbol.hasTypedDeclarations()) {
-            narrowedTypeForSet = isDescriptorApplied ? usage.setType.type : narrowTypeBasedOnAssignment(errorNode, type, usage.setType).type;
+            narrowedTypeForSet = isDescriptorApplied ? usage.setType.type : narrowTypeBasedOnAssignment(type, usage.setType).type;
           }
           if (!assignType(type, usage.setType.type, diag == null ? void 0 : diag.createAddendum())) {
             if (!usage.setType.isIncomplete) {
@@ -74488,7 +74754,7 @@ var require_typeEvaluator = __commonJS({
           }
           return { type: types_1.UnknownType.create(), typeErrors: true };
         }
-        if (!(0, types_1.isFunction)(methodType) && !(0, types_1.isOverloaded)(methodType)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(methodType)) {
           if ((0, types_1.isAnyOrUnknown)(methodType)) {
             return { type: methodType };
           }
@@ -74520,7 +74786,7 @@ var require_typeEvaluator = __commonJS({
             );
             accessMethodClass = solveAndApplyConstraints(accessMethodClass, constraints);
             const specializedType = (0, typeUtils_1.partiallySpecializeType)(methodType, accessMethodClass, getTypeClassType(), selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : classType);
-            if ((0, types_1.isFunction)(specializedType) || (0, types_1.isOverloaded)(specializedType)) {
+            if ((0, types_1.isFunctionOrOverloaded)(specializedType)) {
               methodType = specializedType;
             }
           }
@@ -74773,7 +75039,7 @@ var require_typeEvaluator = __commonJS({
             }
           });
         }
-        if (!(0, types_1.isFunction)(accessMemberType) && !(0, types_1.isOverloaded)(accessMemberType)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(accessMemberType)) {
           if ((0, types_1.isAnyOrUnknown)(accessMemberType)) {
             return { type: accessMemberType };
           }
@@ -74876,13 +75142,25 @@ var require_typeEvaluator = __commonJS({
       function adjustTypeArgsForTypeVarTuple(typeArgs, typeParams, errorNode) {
         const variadicIndex = typeParams.findIndex((param) => (0, types_1.isTypeVarTuple)(param));
         let srcUnboundedTupleType;
-        let srcUnboundedTupleIndex = typeArgs.findIndex((arg) => {
-          if ((0, types_1.isUnpackedClass)(arg.type) && arg.type.priv.tupleTypeArgs && arg.type.priv.tupleTypeArgs.length === 1 && arg.type.priv.tupleTypeArgs[0].isUnbounded) {
-            srcUnboundedTupleType = arg.type.priv.tupleTypeArgs[0].type;
-            return true;
+        const findUnboundedTupleIndex = (startArgIndex) => {
+          return typeArgs.findIndex((arg, index) => {
+            if (index < startArgIndex) {
+              return false;
+            }
+            if ((0, types_1.isUnpackedClass)(arg.type) && arg.type.priv.tupleTypeArgs && arg.type.priv.tupleTypeArgs.length === 1 && arg.type.priv.tupleTypeArgs[0].isUnbounded) {
+              srcUnboundedTupleType = arg.type.priv.tupleTypeArgs[0].type;
+              return true;
+            }
+            return false;
+          });
+        };
+        let srcUnboundedTupleIndex = findUnboundedTupleIndex(0);
+        if (srcUnboundedTupleIndex >= 0) {
+          const secondUnboundedTupleIndex = findUnboundedTupleIndex(srcUnboundedTupleIndex + 1);
+          if (secondUnboundedTupleIndex >= 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), typeArgs[secondUnboundedTupleIndex].node);
           }
-          return false;
-        });
+        }
         if (srcUnboundedTupleType && srcUnboundedTupleIndex >= 0 && variadicIndex >= 0 && typeArgs.length < typeParams.length) {
           while (variadicIndex > srcUnboundedTupleIndex) {
             typeArgs = [
@@ -75811,7 +76089,7 @@ var require_typeEvaluator = __commonJS({
         }
         return typeResult;
       }
-      function buildTupleTypesList(entryTypeResults, stripLiterals) {
+      function buildTupleTypesList(entryTypeResults, stripLiterals, convertModule) {
         const entryTypes = [];
         for (const typeResult of entryTypeResults) {
           let possibleUnpackedTuple;
@@ -75833,12 +76111,7 @@ var require_typeEvaluator = __commonJS({
               true
             ), isUnbounded: false });
           } else {
-            let entryType = convertSpecialFormToRuntimeValue(
-              typeResult.type,
-              0,
-              /* convertModule */
-              true
-            );
+            let entryType = convertSpecialFormToRuntimeValue(typeResult.type, 0, convertModule);
             entryType = stripLiterals ? (0, typeUtils_1.stripTypeForm)(stripLiteralValue(entryType)) : entryType;
             entryTypes.push({ type: entryType, isUnbounded: !!typeResult.unpackedType });
           }
@@ -76336,7 +76609,7 @@ var require_typeEvaluator = __commonJS({
       }
       function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, constraints, skipUnknownArgCheck, inferenceContext) {
         const returnTypes = [];
-        const matchedOverloads = [];
+        let matchedOverloads = [];
         let isTypeIncomplete = false;
         let overloadsUsedForCall = [];
         let isDefinitiveMatchFound = false;
@@ -76387,10 +76660,12 @@ var require_typeEvaluator = __commonJS({
                 argResults: callResult.argResults ?? []
               };
               matchedOverloads.push(matchedOverloadInfo);
-              if (callResult.anyOrUnknownArg) {
+              if (callResult.anyOrUnknownArg || matchResults.unpackedArgOfUnknownLength) {
                 possibleMatchResults.push(matchedOverloadInfo);
-                if ((0, typeUtils_1.isIncompleteUnknown)(callResult.anyOrUnknownArg)) {
-                  possibleMatchInvolvesIncompleteUnknown = true;
+                if (callResult.anyOrUnknownArg) {
+                  if ((0, typeUtils_1.isIncompleteUnknown)(callResult.anyOrUnknownArg)) {
+                    possibleMatchInvolvesIncompleteUnknown = true;
+                  }
                 }
               } else {
                 returnTypes.push(callResult.returnType);
@@ -76400,10 +76675,12 @@ var require_typeEvaluator = __commonJS({
             }
           }
           if (!isDefinitiveMatchFound && possibleMatchResults.length > 0) {
+            possibleMatchResults = filterOverloadMatchesForUnpackedArgs(possibleMatchResults);
             possibleMatchResults = filterOverloadMatchesForAnyArgs(possibleMatchResults);
             if (possibleMatchResults.length === 1) {
               overloadsUsedForCall = [possibleMatchResults[0].overload];
               returnTypes.push(possibleMatchResults[0].returnType);
+              matchedOverloads = [possibleMatchResults[0]];
             } else {
               let dedupedMatchResults = [];
               let dedupedResultsIncludeAny = false;
@@ -76474,15 +76751,19 @@ var require_typeEvaluator = __commonJS({
           overloadsUsedForCall
         };
       }
-      function filterOverloadMatchesForAnyArgs(matches) {
+      function filterOverloadMatchesForUnpackedArgs(matches) {
         if (matches.length < 2) {
           return matches;
         }
-        if (matches[0].matchResults.relevance !== matches[matches.length - 1].matchResults.relevance) {
-          matches = matches.filter((m) => m.matchResults.relevance === matches[0].matchResults.relevance);
-          if (matches.length < 2) {
-            return matches;
-          }
+        const unpackedArgsOverloads = matches.filter((match2) => match2.matchResults.unpackedArgMapsToVariadic);
+        if (unpackedArgsOverloads.length === matches.length || unpackedArgsOverloads.length === 0) {
+          return matches;
+        }
+        return unpackedArgsOverloads;
+      }
+      function filterOverloadMatchesForAnyArgs(matches) {
+        if (matches.length < 2) {
+          return matches;
         }
         if ((0, typeUtils_1.areTypesSame)(matches.map((match2) => match2.returnType), { treatAnySameAsUnknown: true })) {
           return [matches[0]];
@@ -76507,7 +76788,7 @@ var require_typeEvaluator = __commonJS({
       }
       function getBestOverloadForArgs(errorNode, typeResult, argList) {
         let overloadIndex = 0;
-        let matches = [];
+        const matches = [];
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
         useSignatureTracker(errorNode, () => {
           types_1.OverloadedType.getOverloads(typeResult.type).forEach((overload) => {
@@ -76520,7 +76801,6 @@ var require_typeEvaluator = __commonJS({
             });
           });
         });
-        matches = sortOverloadsByBestMatch(matches);
         let winningOverloadIndex;
         matches.forEach((match2, matchIndex) => {
           if (winningOverloadIndex === void 0) {
@@ -76540,16 +76820,8 @@ var require_typeEvaluator = __commonJS({
         });
         return winningOverloadIndex === void 0 ? void 0 : matches[winningOverloadIndex].overload;
       }
-      function sortOverloadsByBestMatch(matches) {
-        return matches.sort((a, b) => {
-          if (a.relevance !== b.relevance) {
-            return b.relevance - a.relevance;
-          }
-          return a.overloadIndex - b.overloadIndex;
-        });
-      }
       function validateOverloadedArgTypes(errorNode, argList, typeResult, constraints, skipUnknownArgCheck, inferenceContext) {
-        let filteredMatchResults = [];
+        const filteredMatchResults = [];
         let contextFreeArgTypes;
         let isTypeIncomplete = !!typeResult.isIncomplete;
         const type = typeResult.type;
@@ -76564,7 +76836,6 @@ var require_typeEvaluator = __commonJS({
             overloadIndex++;
           });
         });
-        filteredMatchResults = sortOverloadsByBestMatch(filteredMatchResults);
         if (filteredMatchResults.length === 0) {
           if (!canSkipDiagnosticForNode(errorNode)) {
             const overloads = types_1.OverloadedType.getOverloads(type);
@@ -76755,22 +77026,33 @@ var require_typeEvaluator = __commonJS({
         };
       }
       function validateCallArgsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext, recursionCount) {
+        function touchArgTypes() {
+          if (!isCallTypeIncomplete) {
+            argList.forEach((arg) => {
+              if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
+                getTypeOfArg(
+                  arg,
+                  /* inferenceContext */
+                  void 0
+                );
+              }
+            });
+          }
+        }
         switch (expandedCallType.category) {
           case 3:
           case 1:
           case 2: {
-            if (!isCallTypeIncomplete) {
-              argList.forEach((arg) => {
-                if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
-                  getTypeOfArg(
-                    arg,
-                    /* inferenceContext */
-                    void 0
-                  );
-                }
-              });
-            }
-            return { returnType: expandedCallType };
+            const dummyFunctionType = types_1.FunctionType.createInstance(
+              "",
+              "",
+              "",
+              0
+              /* FunctionTypeFlags.None */
+            );
+            types_1.FunctionType.addDefaultParams(dummyFunctionType);
+            const dummyCallResult = validateCallForFunction(errorNode, argList, dummyFunctionType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
+            return { ...dummyCallResult, returnType: expandedCallType };
           }
           case 4: {
             return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
@@ -76781,6 +77063,7 @@ var require_typeEvaluator = __commonJS({
           case 6: {
             if ((0, typeUtils_1.isNoneInstance)(expandedCallType)) {
               addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalCall, localize_1.LocMessage.noneNotCallable(), errorNode);
+              touchArgTypes();
               return { argumentErrors: true };
             }
             if (types_1.TypeBase.isInstantiable(expandedCallType)) {
@@ -76797,9 +77080,11 @@ var require_typeEvaluator = __commonJS({
           }
           case 7: {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.moduleNotCallable(), errorNode);
+            touchArgTypes();
             return { argumentErrors: true };
           }
         }
+        touchArgTypes();
         return { argumentErrors: true };
       }
       function validateCallForFunction(errorNode, argList, type, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext) {
@@ -77238,24 +77523,13 @@ var require_typeEvaluator = __commonJS({
         const paramDetails = (0, parameterUtils_1.getParamListDetails)(overload, { disallowExtraKwargsForTd: true });
         const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(overload);
         let argIndex = 0;
-        let matchedUnpackedListOfUnknownLength = false;
+        let unpackedArgOfUnknownLength = false;
+        let unpackedArgMapsToVariadic = false;
         let reportedArgError = false;
         let isTypeIncomplete = !!typeResult.isIncomplete;
         let isTypeVarTupleFullyMatched = false;
         argList = expandArgList(argList);
-        const paramMap = /* @__PURE__ */ new Map();
-        paramDetails.params.forEach((paramInfo) => {
-          var _a2;
-          (0, debug_1.assert)(paramInfo !== void 0, "paramInfo is undefined for param name map");
-          const param = paramInfo.param;
-          if (param.name && param.category === 0 && paramInfo.kind !== parameterUtils_1.ParamKind.Positional) {
-            let argsNeeded = ((_a2 = paramMap.get(param.name)) == null ? void 0 : _a2.argsNeeded) ?? 0;
-            if (param.category === 0 && !paramInfo.defaultType) {
-              argsNeeded += 1;
-            }
-            paramMap.set(param.name, { argsNeeded, argsReceived: 0 });
-          }
-        });
+        const paramTracker = new parameterUtils_1.ParamAssignmentTracker(paramDetails.params);
         let positionalOnlyLimitIndex = paramDetails.positionOnlyParamCount;
         let positionParamLimitIndex = paramDetails.firstKeywordOnlyIndex ?? paramDetails.params.length;
         const varArgListParamIndex = paramDetails.argsIndex;
@@ -77354,6 +77628,8 @@ var require_typeEvaluator = __commonJS({
                 ).type;
                 if ((0, types_1.isClassInstance)(argType) && (0, typeUtils_1.isTupleClass)(argType) && !(0, typeUtils_1.isUnboundedTupleClass)(argType) && argType.priv.tupleTypeArgs !== void 0 && argType.priv.tupleTypeArgs.length > 0) {
                   tooManyPositionals = true;
+                } else {
+                  unpackedArgOfUnknownLength = true;
                 }
               } else {
                 tooManyPositionals = true;
@@ -77385,6 +77661,7 @@ var require_typeEvaluator = __commonJS({
               void 0
             );
             let listElementType;
+            let enforceIterable = false;
             let advanceToNextArg = false;
             if (paramIndex < positionParamLimitIndex) {
               if ((0, types_1.isParamSpec)(argTypeResult.type) && argTypeResult.type.priv.paramSpecAccess === "args" && paramInfo.param.category !== 1) {
@@ -77425,14 +77702,27 @@ var require_typeEvaluator = __commonJS({
                 /* emitNotIterableError */
                 false
               )) == null ? void 0 : _a.type;
+              if (!listElementType) {
+                enforceIterable = true;
+              }
+              unpackedArgOfUnknownLength = true;
               if (paramInfo.param.category === 1) {
-                matchedUnpackedListOfUnknownLength = true;
+                unpackedArgMapsToVariadic = true;
+              }
+              if (isParamVariadic && listElementType) {
+                isArgCompatibleWithVariadic = true;
+                listElementType = (0, tuples_1.makeTupleObject)(
+                  evaluatorInterface,
+                  [{ type: listElementType, isUnbounded: true }],
+                  /* isUnpacked */
+                  true
+                );
               }
             }
             const funcArg = listElementType ? {
               argCategory: 0,
               typeResult: { type: listElementType, isIncomplete: argTypeResult.isIncomplete }
-            } : { ...argList[argIndex] };
+            } : { ...argList[argIndex], enforceIterable };
             if (argTypeResult.isIncomplete) {
               isTypeIncomplete = true;
             }
@@ -77459,8 +77749,8 @@ var require_typeEvaluator = __commonJS({
               }
             }
             trySetActive(argList[argIndex], paramDetails.params[paramIndex].param);
-            if (paramName && paramDetails.params[paramIndex].param.category === 0 && paramMap.has(paramName)) {
-              paramMap.get(paramName).argsReceived++;
+            if (paramName && paramDetails.params[paramIndex].param.category === 0) {
+              paramTracker.markArgReceived(paramInfo);
             }
             if (advanceToNextArg || paramDetails.params[paramIndex].param.category === 1) {
               argIndex++;
@@ -77518,9 +77808,7 @@ var require_typeEvaluator = __commonJS({
               isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(paramInfo2.param)
             });
             trySetActive(argList[argIndex], paramInfo2.param);
-            if (paramName2 && paramMap.has(paramName2) && paramInfo2.kind !== parameterUtils_1.ParamKind.Positional) {
-              paramMap.get(paramName2).argsReceived++;
-            }
+            paramTracker.markArgReceived(paramInfo2);
             argIndex++;
             paramIndex++;
           }
@@ -77566,7 +77854,7 @@ var require_typeEvaluator = __commonJS({
                 const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, argType);
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 tdEntries.knownItems.forEach((entry, name) => {
-                  const paramEntry = paramMap.get(name);
+                  const paramEntry = paramTracker.lookupName(name);
                   if (paramEntry) {
                     if (paramEntry.argsReceived > 0) {
                       diag.addMessage(localize_1.LocMessage.paramAlreadyAssigned().format({ name }));
@@ -77600,10 +77888,7 @@ var require_typeEvaluator = __commonJS({
                       errorNode: argList[argIndex].valueExpression ?? errorNode,
                       paramName: name
                     });
-                    paramMap.set(name, {
-                      argsNeeded: 1,
-                      argsReceived: 1
-                    });
+                    paramTracker.addKeywordParam(name, paramDetails.params[paramDetails.kwargsIndex]);
                   } else {
                     if (!paramDetails.hasUnpackedTypedDict) {
                       diag.addMessage(localize_1.LocMessage.paramNameMissing().format({ name }));
@@ -77679,6 +77964,7 @@ var require_typeEvaluator = __commonJS({
                       unpackedDictArgType = types_1.UnknownType.create();
                     }
                   }
+                  unpackedArgOfUnknownLength = true;
                   if (paramDetails.kwargsIndex !== void 0 && unpackedDictArgType) {
                     const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
                     validateArgTypeParams.push({
@@ -77690,6 +77976,7 @@ var require_typeEvaluator = __commonJS({
                       errorNode: argList[argIndex].valueExpression || errorNode,
                       paramName: paramDetails.params[paramDetails.kwargsIndex].param.name
                     });
+                    unpackedArgMapsToVariadic = true;
                   }
                   if (!isValidMappingType) {
                     if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
@@ -77706,7 +77993,7 @@ var require_typeEvaluator = __commonJS({
               const paramName = argList[argIndex].name;
               if (paramName) {
                 const paramNameValue = paramName.d.value;
-                const paramEntry = paramMap.get(paramNameValue);
+                const paramEntry = paramTracker.lookupName(paramNameValue);
                 if (paramEntry) {
                   if (paramEntry.argsReceived > 0) {
                     if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
@@ -77746,11 +78033,8 @@ var require_typeEvaluator = __commonJS({
                       errorNode: argList[argIndex].valueExpression ?? errorNode,
                       paramName: paramNameValue
                     });
-                    paramMap.set(paramNameValue, {
-                      argsNeeded: 1,
-                      argsReceived: 1
-                    });
                     (0, debug_1.assert)(paramDetails.params[paramDetails.kwargsIndex], "paramDetails.kwargsIndex params entry is undefined");
+                    paramTracker.addKeywordParam(paramNameValue, paramDetails.params[paramDetails.kwargsIndex]);
                   }
                   trySetActive(argList[argIndex], paramDetails.params[paramDetails.kwargsIndex].param);
                 } else {
@@ -77800,7 +78084,7 @@ var require_typeEvaluator = __commonJS({
             paramDetails.params.forEach((paramInfo, paramIndex2) => {
               var _a2;
               const param = paramInfo.param;
-              if (paramIndex2 >= paramDetails.firstPositionOrKeywordIndex && param.category === 0 && param.name && paramMap.has(param.name) && paramMap.get(param.name).argsReceived === 0) {
+              if (paramIndex2 >= paramDetails.firstPositionOrKeywordIndex && param.category === 0 && param.name && paramTracker.lookupDetails(paramInfo).argsReceived === 0) {
                 const paramType = paramDetails.params[paramIndex2].type;
                 if (!unpackedDictKeyNames || unpackedDictKeyNames.includes(param.name)) {
                   validateArgTypeParams.push({
@@ -77818,16 +78102,13 @@ var require_typeEvaluator = __commonJS({
                     paramName: param.name,
                     isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param)
                   });
-                  paramMap.get(param.name).argsReceived = 1;
+                  paramTracker.markArgReceived(paramDetails.params[paramIndex2]);
                 }
               }
             });
           }
           if (!unpackedDictArgType && !types_1.FunctionType.isDefaultParamCheckDisabled(overload)) {
-            const unassignedParams = Array.from(paramMap.keys()).filter((name) => {
-              const entry = paramMap.get(name);
-              return !entry || entry.argsReceived < entry.argsNeeded;
-            });
+            const unassignedParams = paramTracker.getUnassignedParams();
             if (unassignedParams.length > 0) {
               if (!canSkipDiagnosticForNode(errorNode)) {
                 const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(", ");
@@ -77840,21 +78121,24 @@ var require_typeEvaluator = __commonJS({
             paramDetails.params.forEach((paramInfo) => {
               const param = paramInfo.param;
               if (param.category === 0 && param.name) {
-                const entry = paramMap.get(param.name);
-                if (entry && entry.argsNeeded === 0 && entry.argsReceived === 0 && paramInfo.defaultType) {
-                  validateArgTypeParams.push({
-                    paramCategory: param.category,
-                    paramType: paramInfo.type,
-                    requiresTypeVarMatching: true,
-                    argument: {
-                      argCategory: 0,
-                      typeResult: { type: paramInfo.defaultType }
-                    },
-                    isDefaultArg: true,
-                    errorNode,
-                    paramName: param.name,
-                    isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param)
-                  });
+                const entry = paramTracker.lookupDetails(paramInfo);
+                if (entry.argsNeeded === 0 && entry.argsReceived === 0) {
+                  const defaultArgType = paramInfo.defaultType;
+                  if (defaultArgType && !(0, typeUtils_1.isEllipsisType)(defaultArgType) && (0, typeUtils_1.requiresSpecialization)(paramInfo.declaredType, { ignorePseudoGeneric: true })) {
+                    validateArgTypeParams.push({
+                      paramCategory: param.category,
+                      paramType: paramInfo.type,
+                      requiresTypeVarMatching: true,
+                      argument: {
+                        argCategory: 0,
+                        typeResult: { type: defaultArgType }
+                      },
+                      isDefaultArg: true,
+                      errorNode,
+                      paramName: param.name,
+                      isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param)
+                    });
+                  }
                 }
               }
             });
@@ -77919,10 +78203,6 @@ var require_typeEvaluator = __commonJS({
             }
           }
         }
-        let relevance = 0;
-        if (matchedUnpackedListOfUnknownLength) {
-          relevance++;
-        }
         if (types_1.FunctionType.isBuiltIn(overload, ["isinstance", "issubclass"]) && validateArgTypeParams.length === 2) {
           validateArgTypeParams[1].isinstanceParam = true;
         }
@@ -77935,7 +78215,8 @@ var require_typeEvaluator = __commonJS({
           paramSpecTarget,
           paramSpecArgList,
           activeParam,
-          relevance,
+          unpackedArgOfUnknownLength,
+          unpackedArgMapsToVariadic,
           argumentMatchScore: 0
         };
       }
@@ -78175,14 +78456,18 @@ var require_typeEvaluator = __commonJS({
             argumentMatchScore += 1;
           }
         }
-        let returnType = getEffectiveReturnType(type, {
+        const returnTypeResult = getEffectiveReturnTypeResult(type, {
           callSiteInfo: { args: matchResults.argParams, errorNode }
         });
+        let returnType = returnTypeResult.type;
+        if (returnTypeResult.isIncomplete) {
+          isTypeIncomplete = true;
+        }
         if (condition.length > 0) {
           returnType = types_1.TypeBase.cloneForCondition(returnType, condition);
         }
         let eliminateUnsolvedInUnions = true;
-        if ((0, types_1.isFunction)(returnType) || (0, types_1.isOverloaded)(returnType)) {
+        if ((0, types_1.isFunctionOrOverloaded)(returnType)) {
           eliminateUnsolvedInUnions = false;
         }
         let specializedReturnType = solveAndApplyConstraints(returnType, constraints, {
@@ -78276,7 +78561,13 @@ var require_typeEvaluator = __commonJS({
               getTypeOfExpression(arg.valueExpression);
             }
           });
+          const possibleType = types_1.FunctionType.getEffectiveReturnType(typeResult.type);
           return {
+            returnType: possibleType && !(0, types_1.isAnyOrUnknown)(possibleType) ? types_1.UnknownType.createPossibleType(
+              possibleType,
+              /* isIncomplete */
+              false
+            ) : void 0,
             argumentErrors: true,
             activeParam: matchResults.activeParam,
             overloadsUsedForCall: []
@@ -78410,12 +78701,19 @@ var require_typeEvaluator = __commonJS({
             const flags = argParam.isinstanceParam ? 536871546 : 16 | 2;
             const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult == null ? void 0 : typeResult.isIncomplete)));
             argType = exprTypeResult.type;
+            if (argParam.argument.argCategory === 1 && argParam.argument.enforceIterable) {
+              const iteratorType = getTypeOfIterator(
+                exprTypeResult,
+                /* isAsync */
+                false,
+                argParam.argument.valueExpression
+              );
+              argType = (iteratorType == null ? void 0 : iteratorType.type) ?? types_1.UnknownType.create();
+            }
             if (exprTypeResult.isIncomplete) {
               isTypeIncomplete = true;
             }
-            if (exprTypeResult.typeErrors) {
-              isCompatible = false;
-            } else if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
+            if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
               const clonedConstraints = constraints.clone();
               if (assignType(
                 expectedType,
@@ -79382,18 +79680,8 @@ var require_typeEvaluator = __commonJS({
         if (keyValueResult.typeErrors) {
           typeErrors = true;
         }
-        const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(
-          stripLiteralValue(t.type),
-          flags,
-          /* convertModule */
-          true
-        )));
-        const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(
-          stripLiteralValue(t.type),
-          flags,
-          /* convertModule */
-          true
-        )));
+        const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, !hasExpectedType)));
+        const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, !hasExpectedType)));
         if (keyTypes.length > 0) {
           if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.strictDictionaryInference || hasExpectedType) {
             keyType = (0, types_1.combineTypes)(keyTypes);
@@ -79767,12 +80055,7 @@ var require_typeEvaluator = __commonJS({
               /* EvalFlags.StripTupleLiterals */
             );
           }
-          entryTypeResult.type = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(
-            entryTypeResult.type,
-            flags,
-            /* convertModule */
-            true
-          ));
+          entryTypeResult.type = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(entryTypeResult.type, flags, !hasExpectedType));
           if (entryTypeResult.isIncomplete) {
             isIncomplete = true;
           }
@@ -80064,7 +80347,7 @@ var require_typeEvaluator = __commonJS({
               void 0,
               (0, typeUtils_1.makeInferenceContext)(expectedReturnType)
             );
-            functionType.priv.inferredReturnType = {
+            functionType.shared.inferredReturnType = {
               type: returnTypeResult.type
             };
             if (returnTypeResult.isIncomplete) {
@@ -80883,7 +81166,6 @@ var require_typeEvaluator = __commonJS({
             };
             let reportedUnpackedError = false;
             typeArgs.forEach((typeArg, index) => {
-              var _a;
               (0, debug_1.assert)(typeArgs !== void 0);
               if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                 if (!isTupleTypeParam) {
@@ -80906,7 +81188,7 @@ var require_typeEvaluator = __commonJS({
                 }
                 validateTypeVarTupleIsUnpacked(typeArg.type, typeArg.node);
               } else if (paramLimit === void 0 && (0, types_1.isUnpackedClass)(typeArg.type)) {
-                if ((_a = typeArg.type.priv.tupleTypeArgs) == null ? void 0 : _a.some((typeArg2) => (0, types_1.isTypeVarTuple)(typeArg2.type) || typeArg2.isUnbounded)) {
+                if ((0, typeUtils_1.isUnboundedTupleClass)(typeArg.type)) {
                   noteSawUnpacked(typeArg);
                 }
                 validateTypeArg(typeArg, { allowUnpackedTuples: true });
@@ -82115,6 +82397,9 @@ var require_typeEvaluator = __commonJS({
               }
             }
           };
+          if (node.d.name.d.value === "Any" && fileInfo.isTypingStubFile) {
+            decoratedType = types_1.AnyType.createSpecialForm();
+          }
           writeTypeCache(
             node.d.name,
             { type: classType },
@@ -82788,15 +83073,6 @@ var require_typeEvaluator = __commonJS({
           if (functionType.shared.declaredReturnType && returnTypeAnnotationNode) {
             (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParamsSeen, (0, typeUtils_1.getTypeVarArgsRecursive)(functionType.shared.declaredReturnType), functionType.shared.typeVarScopeId);
           }
-          if (fileInfo.isStubFile || ParseTreeUtils.isSuiteEmpty(node.d.suite)) {
-            if (functionType.shared.declaredReturnType && (0, types_1.isClassInstance)(functionType.shared.declaredReturnType) && types_1.ClassType.isBuiltIn(functionType.shared.declaredReturnType, [
-              "Generator",
-              "AsyncGenerator",
-              "AwaitableGenerator"
-            ])) {
-              functionType.shared.flags |= 16;
-            }
-          }
           functionType.shared.typeParams.forEach((typeParam, index) => {
             let bestErrorNode = node.d.name;
             if (node.d.typeParams && index < node.d.typeParams.d.params.length) {
@@ -82901,7 +83177,7 @@ var require_typeEvaluator = __commonJS({
           inferredParamType = (0, types_1.combineTypes)([defaultValueType, types_1.UnknownType.create()]);
         } else {
           let skipInference = false;
-          if ((0, types_1.isFunction)(defaultValueType) || (0, types_1.isOverloaded)(defaultValueType)) {
+          if ((0, types_1.isFunctionOrOverloaded)(defaultValueType)) {
             skipInference = true;
           } else if ((0, types_1.isClassInstance)(defaultValueType) && types_1.ClassType.isBuiltIn(defaultValueType, ["tuple", "list", "set", "dict"])) {
             skipInference = true;
@@ -82961,7 +83237,7 @@ var require_typeEvaluator = __commonJS({
         if (functionType.shared.declaredReturnType) {
           awaitableFunctionType.shared.declaredReturnType = createAwaitableReturnType(node, functionType.shared.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         } else {
-          awaitableFunctionType.priv.inferredReturnType = {
+          awaitableFunctionType.shared.inferredReturnType = {
             type: createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType))
           };
         }
@@ -82984,8 +83260,12 @@ var require_typeEvaluator = __commonJS({
                 }
                 awaitableReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(asyncGeneratorType, typeArgs));
               }
-            } else if (["AsyncGenerator", "AsyncIterator", "AsyncIterable"].some((name) => name === returnType.shared.name)) {
+            } else if (["AsyncIterator", "AsyncIterable"].some((name) => name === returnType.shared.name)) {
               awaitableReturnType = returnType;
+            } else if (returnType.shared.name === "AsyncGenerator") {
+              if (isGenerator) {
+                awaitableReturnType = returnType;
+              }
             }
           }
         }
@@ -83265,6 +83545,7 @@ var require_typeEvaluator = __commonJS({
           return;
         }
         const exprTypeResult = getTypeOfExpression(node.d.expr);
+        let isIncomplete = exprTypeResult.isIncomplete;
         let exprType = exprTypeResult.type;
         const isAsync = node.parent && node.parent.nodeType === 58 && !!node.parent.d.isAsync;
         if ((0, typeUtils_1.isOptionalType)(exprType)) {
@@ -83290,7 +83571,17 @@ var require_typeEvaluator = __commonJS({
               enterDiag.createAddendum()
             );
             if (enterTypeResult) {
-              return isAsync ? getTypeOfAwaitable(enterTypeResult.type, node.d.expr) : enterTypeResult.type;
+              if (isAsync) {
+                if (enterTypeResult.isIncomplete) {
+                  isIncomplete = true;
+                }
+                const asyncResult = getTypeOfAwaitable({ type: enterTypeResult.type }, node.d.expr);
+                if (asyncResult.isIncomplete) {
+                  isIncomplete = true;
+                }
+                return asyncResult.type;
+              }
+              return enterTypeResult.type;
             }
             if (!isAsync) {
               if ((_a = getTypeOfMagicMethodCall(
@@ -83328,18 +83619,28 @@ var require_typeEvaluator = __commonJS({
               exitDiag
             );
             if (exitTypeResult) {
-              return isAsync ? getTypeOfAwaitable(exitTypeResult.type, node.d.expr) : exitTypeResult.type;
+              if (exitTypeResult.isIncomplete) {
+                isIncomplete = true;
+              }
+              if (isAsync) {
+                const asyncResult = getTypeOfAwaitable({ type: exitTypeResult.type }, node.d.expr);
+                if (asyncResult.isIncomplete) {
+                  isIncomplete = true;
+                }
+                return asyncResult.type;
+              }
+              return exitTypeResult.type;
             }
           }
           addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotUsableWith().format({ type: printType(subtype), method: exitMethodName }) + exitDiag.getString(), node.d.expr);
           return types_1.UnknownType.create();
         });
         if (node.d.target) {
-          assignTypeToExpression(node.d.target, { type: scopedType, isIncomplete: exprTypeResult.isIncomplete }, node.d.target);
+          assignTypeToExpression(node.d.target, { type: scopedType, isIncomplete }, node.d.target);
         }
         writeTypeCache(
           node,
-          { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete },
+          { type: scopedType, isIncomplete },
           0
           /* EvalFlags.None */
         );
@@ -84285,7 +84586,7 @@ var require_typeEvaluator = __commonJS({
         if (fileInfo.isStubFile || pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_9) || (0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(errorNode)) || (flags & 4) !== 0) {
           if (types_1.ClassType.isBuiltIn(classType, "type") && typeArgs) {
             if (typeArgs.length >= 1) {
-              if ((0, types_1.isFunction)(typeArgs[0].type) || (0, types_1.isOverloaded)(typeArgs[0].type)) {
+              if ((0, types_1.isFunctionOrOverloaded)(typeArgs[0].type)) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationWithCallable(), typeArgs[0].node);
                 return { type: types_1.UnknownType.create() };
               }
@@ -84786,7 +85087,7 @@ var require_typeEvaluator = __commonJS({
         if (!tracker) {
           return type;
         }
-        if ((0, types_1.isFunction)(type) || (0, types_1.isOverloaded)(type)) {
+        if ((0, types_1.isFunctionOrOverloaded)(type)) {
           return (0, typeUtils_1.ensureSignaturesAreUnique)(type, tracker, node.start);
         }
         return type;
@@ -85058,11 +85359,11 @@ var require_typeEvaluator = __commonJS({
               if (declaration.intrinsicType === "int") {
                 return { type: intType };
               }
-              if (declaration.intrinsicType === "Iterable[str]") {
-                const iterableType = getBuiltInType(declaration.node, "Iterable");
-                if ((0, types_1.isInstantiableClass)(iterableType)) {
+              if (declaration.intrinsicType === "MutableSequence[str]") {
+                const sequenceType = getBuiltInType(declaration.node, "MutableSequence");
+                if ((0, types_1.isInstantiableClass)(sequenceType)) {
                   return {
-                    type: types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(iterableType, [strType]))
+                    type: types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(sequenceType, [strType]))
                   };
                 }
               }
@@ -85331,27 +85632,53 @@ var require_typeEvaluator = __commonJS({
           }
           if (loaderActions.implicitImports) {
             loaderActions.implicitImports.forEach((implicitImport, name) => {
+              const existingLoaderField = moduleType.priv.loaderFields.get(name);
               let symbolType;
               if (implicitImport.isUnresolved) {
                 symbolType = types_1.UnknownType.create();
               } else {
-                const moduleName = moduleType.priv.moduleName ? moduleType.priv.moduleName + "." + name : "";
-                const importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.uri);
+                let importedModuleType;
+                const existingType = existingLoaderField == null ? void 0 : existingLoaderField.getSynthesizedType();
+                if ((existingType == null ? void 0 : existingType.type) && (0, types_1.isModule)(existingType.type)) {
+                  importedModuleType = existingType.type;
+                } else {
+                  const moduleName = moduleType.priv.moduleName ? moduleType.priv.moduleName + "." + name : "";
+                  importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.uri);
+                }
                 symbolType = applyLoaderActionsToModuleType(importedModuleType, implicitImport, importLookup2);
               }
-              const importedModuleSymbol = symbol_1.Symbol.createWithType(0, symbolType);
-              moduleType.priv.loaderFields.set(name, importedModuleSymbol);
+              if (!existingLoaderField) {
+                const importedModuleSymbol = symbol_1.Symbol.createWithType(0, symbolType);
+                moduleType.priv.loaderFields.set(name, importedModuleSymbol);
+              }
             });
           }
           return moduleType;
         }
         if (resolvedDecl.type === 8) {
-          const moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.uri);
-          if (resolvedDecl.symbolName && resolvedDecl.submoduleFallback) {
-            return applyLoaderActionsToModuleType(moduleType, resolvedDecl.submoduleFallback, importLookup);
-          } else {
-            return applyLoaderActionsToModuleType(moduleType, resolvedDecl, importLookup);
+          let moduleType;
+          if (resolvedDecl.node.nodeType === 24) {
+            const cachedType = readTypeCache(
+              resolvedDecl.node.d.module,
+              0
+              /* EvalFlags.None */
+            );
+            if (cachedType && (0, types_1.isModule)(cachedType)) {
+              moduleType = cachedType;
+            }
+          }
+          if (!moduleType) {
+            moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.uri);
+            if (resolvedDecl.node.nodeType === 24) {
+              writeTypeCache(
+                resolvedDecl.node.d.module,
+                { type: moduleType },
+                0
+                /* EvalFlags.None */
+              );
+            }
           }
+          return applyLoaderActionsToModuleType(moduleType, resolvedDecl.symbolName && resolvedDecl.submoduleFallback ? resolvedDecl.submoduleFallback : resolvedDecl, importLookup);
         }
         const declaredType = getTypeForDeclaration(resolvedDecl);
         if (declaredType.type) {
@@ -85802,33 +86129,42 @@ var require_typeEvaluator = __commonJS({
           }
         }
       }
-      function getEffectiveReturnType(type, options) {
+      function getEffectiveReturnType(type) {
+        return getEffectiveReturnTypeResult(type).type;
+      }
+      function getInferredReturnType(type) {
+        return getInferredReturnTypeResult(type).type;
+      }
+      function getEffectiveReturnTypeResult(type, options) {
         const specializedReturnType = types_1.FunctionType.getEffectiveReturnType(
           type,
           /* includeInferred */
           false
         );
         if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
-          return specializedReturnType;
+          return { type: specializedReturnType };
         }
-        return getInferredReturnType(type, options == null ? void 0 : options.callSiteInfo);
+        return getInferredReturnTypeResult(type, options == null ? void 0 : options.callSiteInfo);
       }
-      function _getInferredReturnType(type, callSiteInfo) {
-        var _a, _b, _c;
+      function _getInferredReturnTypeResult(type, callSiteInfo) {
+        var _a, _b, _c, _d;
         let returnType;
         let isIncomplete = false;
         const analyzeUnannotatedFunctions = true;
         if (types_1.FunctionType.isStubDefinition(type)) {
-          return types_1.UnknownType.create();
+          return { type: types_1.UnknownType.create() };
         }
         if (types_1.FunctionType.isParamSpecValue(type)) {
-          return types_1.UnknownType.create();
+          return { type: types_1.UnknownType.create() };
         }
         if (types_1.FunctionType.isOverloaded(type) && !types_1.FunctionType.isSynthesizedMethod(type)) {
-          return types_1.UnknownType.create();
+          return { type: types_1.UnknownType.create() };
         }
-        if (type.priv.inferredReturnType && !type.priv.inferredReturnType.isIncomplete) {
-          returnType = type.priv.inferredReturnType.type;
+        const evalCount = ((_a = type.shared.inferredReturnType) == null ? void 0 : _a.evaluationCount) ?? 0;
+        if (type.shared.inferredReturnType && !type.shared.inferredReturnType.isIncomplete) {
+          returnType = type.shared.inferredReturnType.type;
+        } else if (evalCount > maxReturnTypeInferenceAttempts) {
+          returnType = types_1.UnknownType.create();
         } else {
           if (types_1.FunctionType.isInstanceMethod(type) && type.shared.name === "__init__") {
             returnType = getNoneType();
@@ -85857,16 +86193,16 @@ var require_typeEvaluator = __commonJS({
           if (type.shared.typeVarScopeId) {
             typeVarScopes.push(type.shared.typeVarScopeId);
           }
-          if ((_a = type.shared.methodClass) == null ? void 0 : _a.shared.typeVarScopeId) {
+          if ((_b = type.shared.methodClass) == null ? void 0 : _b.shared.typeVarScopeId) {
             typeVarScopes.push(type.shared.methodClass.shared.typeVarScopeId);
           }
           returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, typeVarScopes);
-          type.priv.inferredReturnType = { type: returnType, isIncomplete };
+          type.shared.inferredReturnType = { type: returnType, isIncomplete, evaluationCount: evalCount + 1 };
         }
         if (!isIncomplete && analyzeUnannotatedFunctions && (0, typeUtils_1.isPartlyUnknown)(returnType) && types_1.FunctionType.hasUnannotatedParams(type) && !types_1.FunctionType.isStubDefinition(type) && !types_1.FunctionType.isPyTypedDefinition(type) && callSiteInfo) {
           let hasDecorators = false;
           let isAsync = false;
-          const declNode = (_b = type.shared.declaration) == null ? void 0 : _b.node;
+          const declNode = (_c = type.shared.declaration) == null ? void 0 : _c.node;
           if (declNode) {
             if (declNode.d.decorators.length > 0) {
               hasDecorators = true;
@@ -85879,14 +86215,14 @@ var require_typeEvaluator = __commonJS({
             const contextualReturnType = inferReturnTypeForCallSite(type, callSiteInfo);
             if (contextualReturnType) {
               returnType = contextualReturnType;
-              if ((_c = type.shared.declaration) == null ? void 0 : _c.node) {
+              if ((_d = type.shared.declaration) == null ? void 0 : _d.node) {
                 const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(type.shared.declaration.node);
                 returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, liveScopeIds);
               }
             }
           }
         }
-        return returnType;
+        return { type: returnType, isIncomplete };
       }
       function inferReturnTypeForCallSite(type, callSiteInfo) {
         const args = callSiteInfo.args;
@@ -86046,9 +86382,9 @@ var require_typeEvaluator = __commonJS({
           typeResult.type = validateSymbolIsTypeExpression(errorNode, typeResult.type, !!typeResult.includesVariableDecl);
         }
         inferReturnTypeIfNecessary(typeResult.type);
-        if (errorNode && selfClass && (0, types_1.isClass)(selfClass) && member.isInstanceMember && (0, types_1.isClass)(member.unspecializedClassType) && (flags & 1024) !== 0 && (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
+        if (errorNode && selfClass && (0, types_1.isClass)(selfClass) && !selfClass.priv.includeSubclasses && member.isInstanceMember && (0, types_1.isClass)(member.unspecializedClassType) && (flags & 1024) !== 0 && (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
           const specializedType = (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.unspecializedClassType, getTypeClassType(), (0, typeUtils_1.selfSpecializeClass)(selfClass, { overrideTypeArgs: true }));
-          if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloaded)(subtype) && (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
+          if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunctionOrOverloaded)(subtype) && (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericInstanceVariableAccess(), errorNode);
           }
         }
@@ -86735,7 +87071,7 @@ var require_typeEvaluator = __commonJS({
               return false;
             }
             return true;
-          } else if ((0, types_1.isFunction)(concreteSrcType) || (0, types_1.isOverloaded)(concreteSrcType)) {
+          } else if ((0, types_1.isFunctionOrOverloaded)(concreteSrcType)) {
             const destCallbackType = getCallbackProtocolType(destType, recursionCount);
             if (destCallbackType) {
               return assignType(destCallbackType, concreteSrcType, diag, constraints, flags, recursionCount);
@@ -86760,21 +87096,20 @@ var require_typeEvaluator = __commonJS({
             }
             const metaclass = concreteSrcType.shared.effectiveMetaclass;
             if (metaclass) {
-              if ((0, types_1.isAnyOrUnknown)(metaclass)) {
-                return true;
-              }
-              if (assignClass(
-                types_1.ClassType.cloneAsInstantiable(destType),
-                metaclass,
-                /* diag */
-                void 0,
-                constraints,
-                flags,
-                recursionCount,
-                /* reportErrorsUsingObjType */
-                true
-              )) {
-                return true;
+              if (!(0, types_1.isAnyOrUnknown)(metaclass)) {
+                if (assignClass(
+                  types_1.ClassType.cloneAsInstantiable(destType),
+                  metaclass,
+                  /* diag */
+                  void 0,
+                  constraints,
+                  flags,
+                  recursionCount,
+                  /* reportErrorsUsingObjType */
+                  true
+                )) {
+                  return true;
+                }
               }
             }
           } else if ((0, types_1.isAnyOrUnknown)(concreteSrcType) && !((_j = concreteSrcType.props) == null ? void 0 : _j.specialForm)) {
@@ -87031,10 +87366,8 @@ var require_typeEvaluator = __commonJS({
                   }
                 }
               }
-              if ((0, types_1.isFunction)(srcSubtype) || (0, types_1.isOverloaded)(srcSubtype)) {
-                if ((0, types_1.isFunction)(destSubtype) || (0, types_1.isOverloaded)(destSubtype)) {
-                  return true;
-                }
+              if ((0, types_1.isFunctionOrOverloaded)(srcSubtype) && (0, types_1.isFunctionOrOverloaded)(destSubtype)) {
+                return true;
               }
               return false;
             });
@@ -87225,7 +87558,7 @@ var require_typeEvaluator = __commonJS({
           recursionCount
         );
       }
-      function isTypeComparable(leftType, rightType) {
+      function isTypeComparable(leftType, rightType, assumeIsOperator = false) {
         var _a, _b;
         if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
           return true;
@@ -87236,10 +87569,10 @@ var require_typeEvaluator = __commonJS({
         if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
           return (0, types_1.isTypeSame)(leftType, rightType, { ignoreConditions: true });
         }
-        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloaded)(leftType);
-        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloaded)(rightType);
-        if (isLeftCallable !== isRightCallable) {
-          return false;
+        const isLeftCallable = (0, types_1.isFunctionOrOverloaded)(leftType);
+        const isRightCallable = (0, types_1.isFunctionOrOverloaded)(rightType);
+        if (isLeftCallable || isRightCallable) {
+          return true;
         }
         if ((0, types_1.isInstantiableClass)(leftType) || (0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, "type")) {
           if ((0, types_1.isInstantiableClass)(rightType) || (0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, "type")) {
@@ -87285,6 +87618,12 @@ var require_typeEvaluator = __commonJS({
             if (assignType(genericLeftType, genericRightType) || assignType(genericRightType, genericLeftType)) {
               return true;
             }
+            if (assumeIsOperator && (0, typeUtils_1.isNoneInstance)(rightType)) {
+              if ((0, typeUtils_1.isNoneInstance)(leftType)) {
+                return true;
+              }
+              return assignType(leftType, rightType);
+            }
             if (types_1.ClassType.isBuiltIn(leftType) && types_1.ClassType.isBuiltIn(rightType) && types_1.TypeBase.isInstance(rightType)) {
               let boolType;
               let intType;
@@ -88095,58 +88434,7 @@ var require_typeEvaluator = __commonJS({
         }
         return canAssign;
       }
-      function replaceTypeArgsWithAny(node, declaredType, assignedType, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-          return void 0;
-        }
-        recursionCount++;
-        if (assignedType.shared.typeParams.length > 0 && assignedType.priv.typeArgs && assignedType.priv.typeArgs.length <= assignedType.shared.typeParams.length && !assignedType.priv.tupleTypeArgs) {
-          const constraints = new constraintTracker_1.ConstraintTracker();
-          (0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.specialize(
-            assignedType,
-            /* typeArgs */
-            void 0
-          ), declaredType, constraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start);
-          let replacedTypeArg = false;
-          const solution = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints).getMainSolutionSet();
-          const newTypeArgs = assignedType.priv.typeArgs.map((typeArg, index) => {
-            const typeParam = assignedType.shared.typeParams[index];
-            const expectedTypeArgType = solution.getType(typeParam);
-            if (expectedTypeArgType) {
-              if ((0, types_1.isAnyOrUnknown)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
-                replacedTypeArg = true;
-                return expectedTypeArgType;
-              }
-              if ((0, types_1.isClassInstance)(expectedTypeArgType) && (0, types_1.isClassInstance)(typeArg)) {
-                const recursiveReplacement = replaceTypeArgsWithAny(node, expectedTypeArgType, typeArg, recursionCount);
-                if (recursiveReplacement) {
-                  replacedTypeArg = true;
-                  return recursiveReplacement;
-                }
-              } else if ((0, typeUtils_1.containsAnyRecursive)(expectedTypeArgType)) {
-                const variance = types_1.TypeVarType.getVariance(typeParam);
-                const isSubtype = assignType(expectedTypeArgType, typeArg);
-                const isSupertype = assignType(typeArg, expectedTypeArgType);
-                if ((variance === 4 || isSubtype) && (variance === 3 || isSupertype)) {
-                  replacedTypeArg = true;
-                  return expectedTypeArgType;
-                }
-              }
-            }
-            return typeArg;
-          });
-          if (replacedTypeArg) {
-            return types_1.ClassType.specialize(assignedType, newTypeArgs);
-          }
-        }
-        if (types_1.ClassType.isSameGenericClass(declaredType, assignedType)) {
-          if ((0, typeUtils_1.containsAnyRecursive)(assignedType) && !(0, typeUtils_1.containsAnyRecursive)(declaredType)) {
-            return declaredType;
-          }
-        }
-        return void 0;
-      }
-      function narrowTypeBasedOnAssignment(node, declaredType, assignedTypeResult) {
+      function narrowTypeBasedOnAssignment(declaredType, assignedTypeResult) {
         const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedTypeResult.type, (assignedSubtype) => {
           if ((0, types_1.isClass)(assignedSubtype) && (0, typeUtils_1.isLiteralType)(assignedSubtype)) {
             if ((0, types_1.isUnion)(declaredType) && types_1.UnionType.containsType(declaredType, assignedSubtype)) {
@@ -88154,33 +88442,24 @@ var require_typeEvaluator = __commonJS({
             }
           }
           const narrowedSubtype = (0, typeUtils_1.mapSubtypes)(declaredType, (declaredSubtype) => {
-            if ((0, types_1.isAnyOrUnknown)(declaredSubtype)) {
-              return declaredSubtype;
+            if (!assignType(declaredSubtype, assignedSubtype)) {
+              return void 0;
             }
-            if (assignType(declaredSubtype, assignedSubtype)) {
-              if ((0, types_1.isAny)(assignedSubtype)) {
-                return declaredSubtype;
-              }
-              if ((0, types_1.isClass)(declaredSubtype) && (0, types_1.isClass)(assignedSubtype) && types_1.TypeBase.isInstance(declaredSubtype) === types_1.TypeBase.isInstance(assignedSubtype)) {
-                const result = replaceTypeArgsWithAny(node, declaredSubtype, assignedSubtype);
-                if (result) {
-                  assignedSubtype = result;
-                }
+            if ((0, types_1.isUnknown)(assignedSubtype)) {
+              return assignedSubtype;
+            }
+            if (assignType(assignedSubtype, declaredSubtype)) {
+              if ((0, types_1.isClass)(assignedSubtype) && assignedSubtype.priv.typedDictNarrowedEntries && (0, types_1.isTypeSame)(assignedSubtype, declaredSubtype, { ignoreTypedDictNarrowEntries: true })) {
                 return assignedSubtype;
               }
-              if (!(0, types_1.isTypeVar)(declaredSubtype) && (0, types_1.isTypeVar)(assignedSubtype) && !types_1.TypeVarType.isBound(assignedSubtype)) {
-                return declaredSubtype;
-              }
-              if ((0, typeUtils_1.containsAnyRecursive)(
-                assignedSubtype,
-                /* includeUnknown */
-                false
-              ) && !(0, typeUtils_1.containsAnyRecursive)(declaredSubtype)) {
-                return declaredSubtype;
+              if ((0, types_1.isClassInstance)(declaredSubtype) && types_1.ClassType.isProtocolClass(declaredSubtype)) {
+                if ((0, types_1.isFunctionOrOverloaded)(assignedSubtype)) {
+                  return assignedSubtype;
+                }
               }
-              return assignedSubtype;
+              return declaredSubtype;
             }
-            return void 0;
+            return assignedSubtype;
           });
           if ((0, types_1.isNever)(narrowedSubtype)) {
             return assignedSubtype;
@@ -88188,14 +88467,14 @@ var require_typeEvaluator = __commonJS({
           return narrowedSubtype;
         });
         if ((0, typeUtils_1.isIncompleteUnknown)(narrowedType)) {
-          return { type: narrowedType };
+          return { type: narrowedType, isIncomplete: assignedTypeResult.isIncomplete };
         } else if ((0, types_1.isUnknown)(narrowedType)) {
-          return { type: (0, types_1.combineTypes)([narrowedType, declaredType]) };
+          return { type: (0, types_1.combineTypes)([narrowedType, declaredType]), isIncomplete: assignedTypeResult.isIncomplete };
         }
-        return { type: narrowedType };
+        return { type: narrowedType, isIncomplete: assignedTypeResult.isIncomplete };
       }
       function validateOverrideMethod(baseMethod, overrideMethod, baseClass, diag, enforceParamNames = true) {
-        if (!(0, types_1.isFunction)(baseMethod) && !(0, types_1.isOverloaded)(baseMethod)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(baseMethod)) {
           diag.addMessage(localize_1.LocAddendum.overrideType().format({ type: printType(baseMethod) }));
           return false;
         }
@@ -88243,9 +88522,7 @@ var require_typeEvaluator = __commonJS({
               overrideOverload,
               /* diag */
               void 0,
-              enforceParamNames,
-              /* exemptSelfClsParam */
-              false
+              enforceParamNames
             );
             if (isCompatible && index <= previousMatchIndex && possibleMatchIndex === void 0) {
               possibleMatchIndex = index;
@@ -88300,7 +88577,7 @@ var require_typeEvaluator = __commonJS({
           /* AssignTypeFlags.Default */
         );
       }
-      function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames, exemptSelfClsParam = true) {
+      function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames) {
         const baseParamDetails = (0, parameterUtils_1.getParamListDetails)(baseMethod);
         const overrideParamDetails = (0, parameterUtils_1.getParamListDetails)(overrideMethod);
         const constraints = new constraintTracker_1.ConstraintTracker();
@@ -88334,8 +88611,8 @@ var require_typeEvaluator = __commonJS({
                   baseParamDetails.params[i].type,
                   diag == null ? void 0 : diag.createAddendum(),
                   constraints,
-                  2
-                  /* AssignTypeFlags.Contravariant */
+                  0
+                  /* AssignTypeFlags.Default */
                 )) {
                   localize_1.LocAddendum.overrideParamType().format({
                     index: i + 1,
@@ -88363,7 +88640,7 @@ var require_typeEvaluator = __commonJS({
           }
           const positionalParamCount = Math.min(baseParamDetails.positionParamCount, overrideParamDetails.positionParamCount);
           for (let i = 0; i < positionalParamCount; i++) {
-            if (i === 0 && exemptSelfClsParam) {
+            if (i === 0) {
               if (types_1.FunctionType.isInstanceMethod(overrideMethod) || types_1.FunctionType.isClassMethod(overrideMethod) || types_1.FunctionType.isConstructorMethod(overrideMethod)) {
                 continue;
               }
@@ -88401,14 +88678,14 @@ var require_typeEvaluator = __commonJS({
               const overrideParamType = overrideParamDetails.params[i].type;
               const baseIsSynthesizedTypeVar = (0, types_1.isTypeVar)(baseParamType) && baseParamType.shared.isSynthesized;
               const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.shared.isSynthesized;
-              if (!exemptSelfClsParam || !baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
+              if (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
                 if (baseParam.category !== overrideParam.category || !assignType(
                   overrideParamType,
                   baseParamType,
                   diag == null ? void 0 : diag.createAddendum(),
                   constraints,
-                  2
-                  /* AssignTypeFlags.Contravariant */
+                  0
+                  /* AssignTypeFlags.Default */
                 )) {
                   diag == null ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamType().format({
                     index: i + 1,
@@ -88452,8 +88729,8 @@ var require_typeEvaluator = __commonJS({
                 baseParamType,
                 diag == null ? void 0 : diag.createAddendum(),
                 constraints,
-                2
-                /* AssignTypeFlags.Contravariant */
+                0
+                /* AssignTypeFlags.Default */
               )) {
                 diag == null ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordType().format({
                   name: overrideParamDetails.params[overrideParamDetails.argsIndex].param.name ?? "?",
@@ -88489,8 +88766,8 @@ var require_typeEvaluator = __commonJS({
                 paramInfo.type,
                 diag == null ? void 0 : diag.createAddendum(),
                 constraints,
-                2
-                /* AssignTypeFlags.Contravariant */
+                0
+                /* AssignTypeFlags.Default */
               )) {
                 diag == null ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordType().format({
                   name: paramInfo.param.name ?? "?",
@@ -88669,6 +88946,9 @@ var require_typeEvaluator = __commonJS({
               true
             );
           }
+          if (functionType.priv.strippedFirstParamType) {
+            return functionType;
+          }
           if (types_1.FunctionType.isInstanceMethod(functionType)) {
             if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
               return functionType;
@@ -88721,6 +89001,18 @@ var require_typeEvaluator = __commonJS({
               constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType) ? (0, typeUtils_1.convertToInstance)(firstParamType) : firstParamType);
             } else {
               const subDiag = diag == null ? void 0 : diag.createAddendum();
+              if ((0, types_1.isFunctionOrOverloaded)(memberTypeFirstParamType)) {
+                if ((0, types_1.isClassInstance)(firstParamType) && types_1.ClassType.isProtocolClass(firstParamType)) {
+                  if (subDiag) {
+                    subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
+                      type: printType(firstParamType),
+                      methodName: memberType.shared.name || "<anonymous>",
+                      paramName: memberTypeFirstParam.name || "__p0"
+                    }));
+                  }
+                  return void 0;
+                }
+              }
               if (!assignType(memberTypeFirstParamType, firstParamType, subDiag == null ? void 0 : subDiag.createAddendum(), constraints, 8192, recursionCount)) {
                 if (memberTypeFirstParam.name && !types_1.FunctionParam.isNameSynthesized(memberTypeFirstParam) && types_1.FunctionParam.isTypeDeclared(memberTypeFirstParam)) {
                   if (subDiag) {
@@ -88973,7 +89265,7 @@ var require_typeEvaluator = __commonJS({
       function printControlFlowGraph(flowNode, reference, callName, logger) {
         return codeFlowEngine.printControlFlowGraph(flowNode, reference, callName, logger);
       }
-      const getInferredReturnType = wrapWithLogger(_getInferredReturnType);
+      const getInferredReturnTypeResult = wrapWithLogger(_getInferredReturnTypeResult);
       const evaluatorInterface = {
         runWithCancellationToken,
         getType,
@@ -89175,6 +89467,7 @@ var require_checker = __commonJS({
         this._isUnboundCheckSuppressed = false;
         this._scopedNodes = [];
         this._typeParamLists = [];
+        this._multipartImports = [];
         this._moduleNode = parseResults.parseTree;
         this._fileInfo = AnalyzerNodeInfo.getFileInfo(this._moduleNode);
       }
@@ -89195,6 +89488,7 @@ var require_checker = __commonJS({
           this._reportUnusedDunderAllSymbols(dunderAllInfo.stringNodes);
         }
         this._validateSymbolTables();
+        this._reportUnusedMultipartImports();
         this._reportDuplicateImports();
       }
       walk(node) {
@@ -89948,7 +90242,9 @@ var require_checker = __commonJS({
         const typeResult = this._evaluator.getTypeResult(node.d.member);
         const type = (typeResult == null ? void 0 : typeResult.type) ?? types_1.UnknownType.create();
         const leftExprType = this._evaluator.getType(node.d.leftExpr);
-        this._reportDeprecatedUseForType(node.d.member, type, leftExprType && (0, types_1.isModule)(leftExprType) && leftExprType.priv.moduleName === "typing");
+        const moduleName = leftExprType && (0, types_1.isModule)(leftExprType) ? leftExprType.priv.moduleName : void 0;
+        const isImportedFromTyping = moduleName === "typing" || moduleName === "typing_extensions";
+        this._reportDeprecatedUseForType(node.d.member, type, isImportedFromTyping);
         if (typeResult == null ? void 0 : typeResult.memberAccessDeprecationInfo) {
           this._reportDeprecatedUseForMemberAccess(node.d.member, typeResult.memberAccessDeprecationInfo);
         }
@@ -89959,6 +90255,10 @@ var require_checker = __commonJS({
       visitImportAs(node) {
         this._conditionallyReportShadowedImport(node);
         this._evaluator.evaluateTypesForStatement(node);
+        const nameParts = node.d.module.d.nameParts;
+        if (nameParts.length > 1 && !node.d.alias) {
+          this._multipartImports.push(node);
+        }
         return true;
       }
       visitImportFrom(node) {
@@ -90013,7 +90313,8 @@ var require_checker = __commonJS({
         let isImportFromTyping = false;
         if (((_b = node.parent) == null ? void 0 : _b.nodeType) === 25) {
           if (node.parent.d.module.d.leadingDots === 0 && node.parent.d.module.d.nameParts.length === 1) {
-            if (node.parent.d.module.d.nameParts[0].d.value === "typing") {
+            const namePart = node.parent.d.module.d.nameParts[0].d.value;
+            if (namePart === "typing" || namePart === "typing_extensions") {
               isImportFromTyping = true;
             }
           }
@@ -90103,6 +90404,49 @@ var require_checker = __commonJS({
         }
         return false;
       }
+      _reportUnusedMultipartImports() {
+        this._multipartImports.forEach((node) => {
+          const nameParts = node.d.module.d.nameParts;
+          if (this._isMultipartImportUnused(node)) {
+            const multipartName = nameParts.map((np) => np.d.value).join(".");
+            let textRange = { start: nameParts[0].start, length: nameParts[0].length };
+            textRange = textRange_1.TextRange.extend(textRange, nameParts[nameParts.length - 1]);
+            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: multipartName }), textRange, {
+              action: "pyright.unusedImport"
+              /* Commands.unusedImport */
+            });
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.LocMessage.unaccessedImport().format({ name: multipartName }), textRange);
+          }
+        });
+      }
+      _isMultipartImportUnused(node) {
+        var _a;
+        const nameParts = node.d.module.d.nameParts;
+        (0, debug_1.assert)(nameParts.length > 1);
+        let moduleType = (_a = this._evaluator.evaluateTypeForSubnode(node, () => {
+          this._evaluator.evaluateTypesForStatement(node);
+        })) == null ? void 0 : _a.type;
+        if (!moduleType || !(0, types_1.isModule)(moduleType)) {
+          return false;
+        }
+        for (let i = 1; i < nameParts.length - 1; i++) {
+          const symbol2 = types_1.ModuleType.getField(moduleType, nameParts[i].d.value);
+          if (!symbol2) {
+            return false;
+          }
+          const submoduleType = symbol2.getSynthesizedType();
+          if (!submoduleType || !(0, types_1.isModule)(submoduleType.type)) {
+            return false;
+          }
+          moduleType = submoduleType.type;
+        }
+        const lastPartName = nameParts[nameParts.length - 1].d.value;
+        const symbol = types_1.ModuleType.getField(moduleType, lastPartName);
+        if (!symbol) {
+          return false;
+        }
+        return !this._fileInfo.accessedSymbolSet.has(symbol.id);
+      }
       _getImportResult(node, uri) {
         const execEnv = this._importResolver.getConfigOptions().findExecEnvironment(uri);
         const moduleNameNode = node.parent.d.module;
@@ -90186,7 +90530,7 @@ var require_checker = __commonJS({
         let isCoroutine = true;
         (0, typeUtils_1.doForEachSubtype)(exprTypeResult.type, (subtype) => {
           subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
-          if (!(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloaded)(subtype)) {
+          if (!(0, types_1.isFunctionOrOverloaded)(subtype)) {
             isExprFunction = false;
           }
           if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, ["Coroutine", "CoroutineType"])) {
@@ -90317,6 +90661,7 @@ var require_checker = __commonJS({
       // have overlapping types.
       _validateComparisonTypes(node) {
         let rightExpression = node.d.rightExpr;
+        const assumeIsOperator = node.d.operator === 39 || node.d.operator === 40;
         if (rightExpression.nodeType === 7 && !rightExpression.d.hasParens && ParseTreeUtils.operatorSupportsChaining(rightExpression.d.operator)) {
           rightExpression = rightExpression.d.leftExpr;
         }
@@ -90361,7 +90706,7 @@ var require_checker = __commonJS({
               if (isComparable) {
                 return;
               }
-              if (this._evaluator.isTypeComparable(leftSubtype, rightSubtype)) {
+              if (this._evaluator.isTypeComparable(leftSubtype, rightSubtype, assumeIsOperator)) {
                 isComparable = true;
               }
               return rightSubtype;
@@ -91372,16 +91717,10 @@ var require_checker = __commonJS({
                 }
               } else {
                 const nameParts = decl.node.d.module.d.nameParts;
-                if (nameParts.length > 0) {
-                  const multipartName = nameParts.map((np) => np.d.value).join(".");
-                  let textRange = { start: nameParts[0].start, length: nameParts[0].length };
-                  textRange = textRange_1.TextRange.extend(textRange, nameParts[nameParts.length - 1]);
-                  this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: multipartName }), textRange, {
-                    action: "pyright.unusedImport"
-                    /* Commands.unusedImport */
-                  });
-                  this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.LocMessage.unaccessedImport().format({ name: multipartName }), textRange);
-                  return;
+                if (nameParts.length === 1) {
+                  nameNode = nameParts[0];
+                  this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.LocMessage.unaccessedImport().format({ name: nameNode.d.value }), nameNode);
+                  message = localize_1.LocMessage.unaccessedImport().format({ name: nameNode.d.value });
                 }
               }
             } else if (decl.node.nodeType === 26) {
@@ -91594,7 +91933,7 @@ var require_checker = __commonJS({
       _isTypeSupportedTypeForIsInstance(type, isInstanceCheck, diag) {
         let isSupported = true;
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-          var _a, _b;
+          var _a, _b, _c;
           subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
           subtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
           if (((_a = subtype.props) == null ? void 0 : _a.specialForm) && types_1.ClassType.isBuiltIn(subtype.props.specialForm, "TypeAliasType")) {
@@ -91635,6 +91974,9 @@ var require_checker = __commonJS({
               } else if (((_b = subtype.props) == null ? void 0 : _b.specialForm) && (0, types_1.isClassInstance)(subtype.props.specialForm) && types_1.ClassType.isBuiltIn(subtype.props.specialForm, "Annotated")) {
                 diag.addMessage(localize_1.LocAddendum.annotatedNotAllowed());
                 isSupported = false;
+              } else if (((_c = subtype.props) == null ? void 0 : _c.specialForm) && (0, types_1.isInstantiableClass)(subtype.props.specialForm) && types_1.ClassType.isBuiltIn(subtype.props.specialForm, "Literal")) {
+                diag.addMessage(localize_1.LocAddendum.literalNotAllowed());
+                isSupported = false;
               }
               break;
             case 4:
@@ -92102,7 +92444,7 @@ var require_checker = __commonJS({
           }
           if (declaredReturnType && !functionNeverReturns && implicitlyReturnsNone) {
             if ((0, types_1.isNever)(declaredReturnType)) {
-              if (!ParseTreeUtils.isSuiteEmpty(node.d.suite) && !types_1.FunctionType.isOverloaded(functionType) && !types_1.FunctionType.isAsync(functionType)) {
+              if (!ParseTreeUtils.isSuiteEmpty(node.d.suite) && !types_1.FunctionType.isOverloaded(functionType)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.noReturnReturnsNone(), returnAnnotation);
               }
             } else if (!types_1.FunctionType.isAbstractMethod(functionType)) {
@@ -92615,7 +92957,7 @@ var require_checker = __commonJS({
           return;
         }
         let newMemberType = newMethodResult.type;
-        if (!(0, types_1.isFunction)(newMemberType) && !(0, types_1.isOverloaded)(newMemberType)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(newMemberType)) {
           return;
         }
         if ((0, types_1.isOverloaded)(newMemberType)) {
@@ -92625,7 +92967,7 @@ var require_checker = __commonJS({
           }
         }
         let initMemberType = initMethodResult.type;
-        if (!(0, types_1.isFunction)(initMemberType) && !(0, types_1.isOverloaded)(initMemberType)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(initMemberType)) {
           return;
         }
         if ((0, types_1.isOverloaded)(initMemberType)) {
@@ -92796,9 +93138,9 @@ var require_checker = __commonJS({
         let diag;
         const overrideDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideClassAndSymbol.symbol);
         const overriddenDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overriddenClassAndSymbol.symbol);
-        if ((0, types_1.isFunction)(overriddenType) || (0, types_1.isOverloaded)(overriddenType)) {
+        if ((0, types_1.isFunctionOrOverloaded)(overriddenType)) {
           const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-          if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloaded)(overrideType)) {
+          if ((0, types_1.isFunctionOrOverloaded)(overrideType)) {
             if (!this._evaluator.validateOverrideMethod(
               overriddenType,
               overrideType,
@@ -93254,13 +93596,14 @@ var require_checker = __commonJS({
         }
         const baseClass = baseClassAndSymbol.classType;
         const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType, { useBoundTypeVars: true }));
-        let baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), childClassSelf);
+        const baseClassSelf = types_1.ClassType.isProtocolClass(baseClass) ? childClassSelf : types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(baseClass, { useBoundTypeVars: true }));
+        let baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), baseClassSelf);
         overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, this._evaluator.getTypeClassType(), childClassSelf);
         if (childClassType.shared.typeVarScopeId) {
           overrideType = (0, typeUtils_1.makeTypeVarsBound)(overrideType, [childClassType.shared.typeVarScopeId]);
           baseType = (0, typeUtils_1.makeTypeVarsBound)(baseType, [childClassType.shared.typeVarScopeId]);
         }
-        if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloaded)(baseType)) {
+        if ((0, types_1.isFunctionOrOverloaded)(baseType)) {
           const diagAddendum = new diagnostic_1.DiagnosticAddendum();
           if (this._isFinalFunction(memberName, baseType)) {
             const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
@@ -93278,7 +93621,7 @@ var require_checker = __commonJS({
           if (this._isMethodExemptFromLsp(memberName) || SymbolNameUtils.isPrivateName(memberName) || types_1.ClassType.isTypedDictClass(childClassType)) {
             return;
           }
-          if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloaded)(overrideType)) {
+          if ((0, types_1.isFunctionOrOverloaded)(overrideType)) {
             const enforceParamNameMatch = !SymbolNameUtils.isDunderName(memberName);
             if (this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
               return;
@@ -94702,7 +95045,8 @@ var require_sourceFile = __commonJS({
               importedModules: [],
               futureImports: /* @__PURE__ */ new Set(),
               containsWildcardImport: false,
-              typingSymbolAliases: /* @__PURE__ */ new Map()
+              typingSymbolAliases: /* @__PURE__ */ new Map(),
+              hasTypeAnnotations: false
             };
             this._writableData.tokenizerLines = new textRangeCollection_1.TextRangeCollection([]);
             this._writableData.tokenizerOutput = {
@@ -95238,6 +95582,8 @@ var require_parser = __commonJS({
         this._isParsingTypeAnnotation = false;
         this._isParsingIndexTrailer = false;
         this._isParsingQuotedText = false;
+        this._isInFinallyBlock = false;
+        this._isInFinallyLoop = false;
         this._futureImports = /* @__PURE__ */ new Set();
         this._importedModules = [];
         this._containsWildcardImport = false;
@@ -95245,8 +95591,10 @@ var require_parser = __commonJS({
         this._typingImportAliases = [];
         this._typingSymbolAliases = /* @__PURE__ */ new Map();
         this._maxChildDepthMap = /* @__PURE__ */ new Map();
+        this._hasTypeAnnotations = false;
       }
       parseSourceFile(fileContents, parseOptions, diagSink) {
+        this._hasTypeAnnotations = false;
         timing_1.timingStats.tokenizeFileTime.timeOperation(() => {
           this._startNewParse(fileContents, 0, fileContents.length, parseOptions, diagSink);
         });
@@ -95288,7 +95636,8 @@ var require_parser = __commonJS({
             importedModules: this._importedModules,
             futureImports: this._futureImports,
             containsWildcardImport: this._containsWildcardImport,
-            typingSymbolAliases: this._typingSymbolAliases
+            typingSymbolAliases: this._typingSymbolAliases,
+            hasTypeAnnotations: this._hasTypeAnnotations
           },
           tokenizerOutput: this._tokenizerOutput
         };
@@ -96296,6 +96645,8 @@ var require_parser = __commonJS({
       _parseLoopSuite() {
         const wasInLoop = this._isInLoop;
         this._isInLoop = true;
+        const wasInFinallyLoop = this._isInFinallyLoop;
+        this._isInFinallyLoop = false;
         let typeComment;
         const suite = this._parseSuite(
           this._isInFunction,
@@ -96309,6 +96660,7 @@ var require_parser = __commonJS({
           }
         );
         this._isInLoop = wasInLoop;
+        this._isInFinallyLoop = wasInFinallyLoop;
         if (typeComment) {
           suite.d.typeComment = typeComment;
         }
@@ -96736,7 +97088,13 @@ var require_parser = __commonJS({
           16
           /* KeywordType.Finally */
         )) {
+          const wasInFinallyBlock = this._isInFinallyBlock;
+          const wasInFinallyLoop = this._isInFinallyLoop;
+          this._isInFinallyBlock = true;
+          this._isInFinallyLoop = this._isInLoop;
           tryNode.d.finallySuite = this._parseSuite(this._isInFunction);
+          this._isInFinallyBlock = wasInFinallyBlock;
+          this._isInFinallyLoop = wasInFinallyLoop;
           tryNode.d.finallySuite.parent = tryNode;
           (0, parseNodes_1.extendRange)(tryNode, tryNode.d.finallySuite);
         }
@@ -96798,6 +97156,10 @@ var require_parser = __commonJS({
         let functionTypeAnnotationToken;
         const wasInExceptionGroup = this._isInExceptionGroup;
         this._isInExceptionGroup = false;
+        const wasInFinallyBlock = this._isInFinallyBlock;
+        const wasInFinallyLoop = this._isInFinallyLoop;
+        this._isInFinallyBlock = false;
+        this._isInFinallyLoop = false;
         const suite = this._parseSuite(
           /* isFunction */
           true,
@@ -96809,6 +97171,8 @@ var require_parser = __commonJS({
           }
         );
         this._isInExceptionGroup = wasInExceptionGroup;
+        this._isInFinallyBlock = wasInFinallyBlock;
+        this._isInFinallyLoop = wasInFinallyLoop;
         const functionNode = parseNodes_1.FunctionNode.create(defToken, parseNodes_1.NameNode.create(nameToken), suite, typeParameters);
         if (asyncToken) {
           functionNode.d.isAsync = true;
@@ -97305,6 +97669,9 @@ var require_parser = __commonJS({
         } else if (this._isInExceptionGroup) {
           this._addSyntaxError(localize_1.LocMessage.breakInExceptionGroup(), breakToken);
         }
+        if (this._isInFinallyLoop && pythonVersion_1.PythonVersion.isGreaterOrEqualTo(this._getLanguageVersion(), pythonVersion_1.pythonVersion3_14)) {
+          this._addSyntaxError(localize_1.LocMessage.finallyBreak(), breakToken);
+        }
         return parseNodes_1.BreakNode.create(breakToken);
       }
       _parseContinueStatement() {
@@ -97317,6 +97684,9 @@ var require_parser = __commonJS({
         } else if (this._isInExceptionGroup) {
           this._addSyntaxError(localize_1.LocMessage.continueInExceptionGroup(), continueToken);
         }
+        if (this._isInFinallyLoop && pythonVersion_1.PythonVersion.isGreaterOrEqualTo(this._getLanguageVersion(), pythonVersion_1.pythonVersion3_14)) {
+          this._addSyntaxError(localize_1.LocMessage.finallyContinue(), continueToken);
+        }
         return parseNodes_1.ContinueNode.create(continueToken);
       }
       // return_stmt: 'return' [testlist]
@@ -97331,6 +97701,9 @@ var require_parser = __commonJS({
         } else if (this._isInExceptionGroup) {
           this._addSyntaxError(localize_1.LocMessage.returnInExceptionGroup(), returnToken);
         }
+        if (this._isInFinallyBlock && pythonVersion_1.PythonVersion.isGreaterOrEqualTo(this._getLanguageVersion(), pythonVersion_1.pythonVersion3_14)) {
+          this._addSyntaxError(localize_1.LocMessage.finallyReturn(), returnToken);
+        }
         if (!this._isNextTokenNeverExpression()) {
           const returnExpr = this._parseTestOrStarListAsExpression(
             /* allowAssignmentExpression */
@@ -99323,6 +99696,7 @@ var require_parser = __commonJS({
           result = parseNodes_1.UnpackNode.create(startToken, result);
         }
         this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
+        this._hasTypeAnnotations = true;
         return result;
       }
       _reportStringTokenErrors(stringToken, unescapedResult) {
@@ -106016,7 +106390,7 @@ var require_AnimationFrameAction = __commonJS({
           return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);
         }
         var actions = scheduler.actions;
-        if (id != null && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id) {
+        if (id != null && id === scheduler._scheduled && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id) {
           animationFrameProvider_1.animationFrameProvider.cancelAnimationFrame(id);
           scheduler._scheduled = void 0;
         }
@@ -106061,8 +106435,13 @@ var require_AnimationFrameScheduler = __commonJS({
       }
       AnimationFrameScheduler2.prototype.flush = function(action) {
         this._active = true;
-        var flushId = this._scheduled;
-        this._scheduled = void 0;
+        var flushId;
+        if (action) {
+          flushId = action.id;
+        } else {
+          flushId = this._scheduled;
+          this._scheduled = void 0;
+        }
         var actions = this.actions;
         var error;
         action = action || actions.shift();
@@ -110546,7 +110925,6 @@ var require_merge2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.merge = void 0;
     var lift_1 = require_lift();
-    var argsOrArgArray_1 = require_argsOrArgArray();
     var mergeAll_1 = require_mergeAll();
     var args_1 = require_args();
     var from_1 = require_from();
@@ -110557,7 +110935,6 @@ var require_merge2 = __commonJS({
       }
       var scheduler = args_1.popScheduler(args);
       var concurrent = args_1.popNumber(args, Infinity);
-      args = argsOrArgArray_1.argsOrArgArray(args);
       return lift_1.operate(function(source, subscriber) {
         mergeAll_1.mergeAll(concurrent)(from_1.from(__spreadArray([source], __read(args)), scheduler)).subscribe(subscriber);
       });
@@ -115805,6 +116182,9 @@ var PythonCodeActionProvider = class {
   ignoreAction(document, range) {
     const ignoreTxt = "# type: ignore";
     const doc = import_coc4.workspace.getDocument(document.uri);
+    if (!doc) {
+      return null;
+    }
     if (this.wholeRange(document, range)) {
       let pos = import_coc4.Position.create(0, 0);
       if (doc.getline(0).startsWith("#!")) pos = import_coc4.Position.create(1, 0);
@@ -116897,7 +117277,7 @@ var TypeInlayHintsProvider = class {
     });
     import_coc11.workspace.onDidChangeTextDocument((e) => {
       const doc = import_coc11.workspace.getDocument(e.bufnr);
-      if (doc.languageId === "python") {
+      if ((doc == null ? void 0 : doc.languageId) === "python") {
         this._onDidChangeInlayHints.fire();
       }
     });
@@ -118911,6 +119291,9 @@ var PyDocStyle = class extends BaseLinter {
       outputLines.push(oldOutputLines[2 * counter] + oldOutputLines[2 * counter + 1]);
     }
     const doc = import_coc21.workspace.getDocument(document.uri);
+    if (!doc) {
+      return [];
+    }
     return outputLines.filter((value, index) => index < maxLines && value.indexOf(":") >= 0).map((line) => {
       if (this.isWindows) {
         return line.substring(line.indexOf(`${baseFileName}:`) + baseFileName.length + 1).trim();
@@ -119304,14 +119687,15 @@ var LintingEngine = class {
     this.diagnosticCollection.set(document.uri, diagnostics);
   }
   createDiagnostics(message, document) {
+    var _a;
     let start = import_coc27.Position.create(message.line > 0 ? message.line - 1 : 0, message.column);
     const endLine = message.endLine ?? message.line;
     const endColumn = message.endColumn ?? message.column + 1;
     let end = import_coc27.Position.create(endLine > 0 ? endLine - 1 : 0, endColumn);
     const ms = /['"](.*?)['"]/g.exec(message.message);
     if (ms && ms.length > 0) {
-      const line = import_coc27.workspace.getDocument(document.uri).getline(message.line - 1);
-      if (line.includes(ms[1])) {
+      const line = (_a = import_coc27.workspace.getDocument(document.uri)) == null ? void 0 : _a.getline(message.line - 1);
+      if (line == null ? void 0 : line.includes(ms[1])) {
         const s = message.column > line.indexOf(ms[1]) ? message.column : line.indexOf(ms[1]);
         start = import_coc27.Position.create(message.line - 1, s);
         end = import_coc27.Position.create(message.line - 1, s + ms[1].length);
@@ -119447,6 +119831,9 @@ var LinterProvider = class {
   }
   onDocumentChanged(e) {
     const document = import_coc28.workspace.getDocument(e.textDocument.uri);
+    if (!document) {
+      return;
+    }
     this.engine.lintDocument(document.textDocument, true).catch(() => {
     });
   }
@@ -119623,6 +120010,9 @@ async function extractVariable(root, document, range, outputChannel) {
     return;
   }
   const doc = import_coc29.workspace.getDocument(document.uri);
+  if (!doc) {
+    return;
+  }
   const tempFile = await getTempFileWithDocumentContents(document);
   const workspaceFolder = import_coc29.workspace.getWorkspaceFolder(doc.uri);
   const workspaceRoot = workspaceFolder ? import_coc29.Uri.parse(workspaceFolder.uri).fsPath : import_coc29.workspace.cwd;
@@ -119644,6 +120034,9 @@ async function extractMethod(root, document, range, outputChannel) {
     return;
   }
   const doc = import_coc29.workspace.getDocument(document.uri);
+  if (!doc) {
+    return;
+  }
   const tempFile = await getTempFileWithDocumentContents(document);
   const workspaceFolder = import_coc29.workspace.getWorkspaceFolder(doc.uri);
   const workspaceRoot = workspaceFolder ? import_coc29.Uri.parse(workspaceFolder.uri).fsPath : import_coc29.workspace.cwd;
@@ -119942,6 +120335,7 @@ async function activate(context) {
   }
   if (pyrightCfg.get("disableDiagnostics")) {
     disabledFeatures.push("diagnostics");
+    disabledFeatures.push("pullDiagnostic");
   }
   if (pyrightCfg.get("disableDocumentation")) {
     disabledFeatures.push("hover");