coc-pyright 1.1.228 → 1.1.232

package/lib/index.js

@@ -1,6 +1,8 @@
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
@@ -18,6 +20,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
@@ -5060,8 +5063,8 @@ var require_lib = __commonJS({
 var require_untildify = __commonJS({
   "node_modules/untildify/index.js"(exports, module2) {
     "use strict";
-    var os = require("os");
-    var homeDirectory = os.homedir();
+    var os2 = require("os");
+    var homeDirectory = os2.homedir();
     module2.exports = (pathWithTilde) => {
       if (typeof pathWithTilde !== "string") {
         throw new TypeError(`Expected a string, got ${typeof pathWithTilde}`);
@@ -15030,7 +15033,7 @@ var require_interval = __commonJS({
     exports.interval = void 0;
     var async_1 = require_async();
     var timer_1 = require_timer();
-    function interval(period, scheduler) {
+    function interval2(period, scheduler) {
       if (period === void 0) {
         period = 0;
       }
@@ -15042,7 +15045,7 @@ var require_interval = __commonJS({
       }
       return timer_1.timer(period, period, scheduler);
     }
-    exports.interval = interval;
+    exports.interval = interval2;
   }
 });
 
@@ -18541,17 +18544,17 @@ var require_timeInterval = __commonJS({
         var last = scheduler.now();
         source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function(value) {
           var now = scheduler.now();
-          var interval = now - last;
+          var interval2 = now - last;
           last = now;
-          subscriber.next(new TimeInterval(value, interval));
+          subscriber.next(new TimeInterval(value, interval2));
         }));
       });
     }
     exports.timeInterval = timeInterval;
     var TimeInterval = function() {
-      function TimeInterval2(value, interval) {
+      function TimeInterval2(value, interval2) {
         this.value = value;
-        this.interval = interval;
+        this.interval = interval2;
       }
       return TimeInterval2;
     }();
@@ -21223,6 +21226,12 @@ var _PythonSettings = class {
       return process.platform === "win32" ? import_path.default.join(p, "Scripts", "python.exe") : import_path.default.join(p, "bin", "python");
     }
     try {
+      if (process.env.VIRTUAL_ENV && import_fs_extra.default.existsSync(import_path.default.join(process.env.VIRTUAL_ENV, "pyvenv.cfg"))) {
+        return pythonBinFromPath(process.env.VIRTUAL_ENV);
+      }
+      if (process.env.CONDA_PREFIX) {
+        return pythonBinFromPath(process.env.CONDA_PREFIX);
+      }
       let p = import_path.default.join(this.workspaceRoot, ".python-version");
       if (import_fs_extra.default.existsSync(p)) {
         if (!process.env.PYENV_VERSION) {
@@ -21249,12 +21258,6 @@ var _PythonSettings = class {
           return pythonBinFromPath(info);
         }
       }
-      if (process.env.VIRTUAL_ENV && import_fs_extra.default.existsSync(import_path.default.join(process.env.VIRTUAL_ENV, "pyvenv.cfg"))) {
-        return pythonBinFromPath(process.env.VIRTUAL_ENV);
-      }
-      if (process.env.CONDA_PREFIX) {
-        return pythonBinFromPath(process.env.CONDA_PREFIX);
-      }
       const files = import_fs_extra.default.readdirSync(this.workspaceRoot);
       for (const file of files) {
         const x = import_path.default.join(this.workspaceRoot, file);
@@ -22012,32 +22015,152 @@ var DarkerFormatter = class extends BaseFormatter {
 };
 
 // src/formatters/blackd.ts
-var import_coc7 = require("coc.nvim");
 var import_child_process2 = require("child_process");
+var import_coc7 = require("coc.nvim");
+
+// node_modules/get-port/index.js
+var import_node_net = __toESM(require("net"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var Locked = class extends Error {
+  constructor(port) {
+    super(`${port} is locked`);
+  }
+};
+var lockedPorts = {
+  old: /* @__PURE__ */ new Set(),
+  young: /* @__PURE__ */ new Set()
+};
+var releaseOldLockedPortsIntervalMs = 1e3 * 15;
+var interval;
+var getLocalHosts = () => {
+  const interfaces = import_node_os.default.networkInterfaces();
+  const results = /* @__PURE__ */ new Set([void 0, "0.0.0.0"]);
+  for (const _interface of Object.values(interfaces)) {
+    for (const config of _interface) {
+      results.add(config.address);
+    }
+  }
+  return results;
+};
+var checkAvailablePort = (options) => new Promise((resolve, reject) => {
+  const server = import_node_net.default.createServer();
+  server.unref();
+  server.on("error", reject);
+  server.listen(options, () => {
+    const { port } = server.address();
+    server.close(() => {
+      resolve(port);
+    });
+  });
+});
+var getAvailablePort = async (options, hosts) => {
+  if (options.host || options.port === 0) {
+    return checkAvailablePort(options);
+  }
+  for (const host of hosts) {
+    try {
+      await checkAvailablePort({ port: options.port, host });
+    } catch (error) {
+      if (!["EADDRNOTAVAIL", "EINVAL"].includes(error.code)) {
+        throw error;
+      }
+    }
+  }
+  return options.port;
+};
+var portCheckSequence = function* (ports) {
+  if (ports) {
+    yield* ports;
+  }
+  yield 0;
+};
+async function getPorts(options) {
+  let ports;
+  let exclude = /* @__PURE__ */ new Set();
+  if (options) {
+    if (options.port) {
+      ports = typeof options.port === "number" ? [options.port] : options.port;
+    }
+    if (options.exclude) {
+      const excludeIterable = options.exclude;
+      if (typeof excludeIterable[Symbol.iterator] !== "function") {
+        throw new TypeError("The `exclude` option must be an iterable.");
+      }
+      for (const element of excludeIterable) {
+        if (typeof element !== "number") {
+          throw new TypeError("Each item in the `exclude` option must be a number corresponding to the port you want excluded.");
+        }
+        if (!Number.isSafeInteger(element)) {
+          throw new TypeError(`Number ${element} in the exclude option is not a safe integer and can't be used`);
+        }
+      }
+      exclude = new Set(excludeIterable);
+    }
+  }
+  if (interval === void 0) {
+    interval = setInterval(() => {
+      lockedPorts.old = lockedPorts.young;
+      lockedPorts.young = /* @__PURE__ */ new Set();
+    }, releaseOldLockedPortsIntervalMs);
+    if (interval.unref) {
+      interval.unref();
+    }
+  }
+  const hosts = getLocalHosts();
+  for (const port of portCheckSequence(ports)) {
+    try {
+      if (exclude.has(port)) {
+        continue;
+      }
+      let availablePort = await getAvailablePort(__spreadProps(__spreadValues({}, options), { port }), hosts);
+      while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
+        if (port !== 0) {
+          throw new Locked(port);
+        }
+        availablePort = await getAvailablePort(__spreadProps(__spreadValues({}, options), { port }), hosts);
+      }
+      lockedPorts.young.add(availablePort);
+      return availablePort;
+    } catch (error) {
+      if (!["EADDRINUSE", "EACCES"].includes(error.code) && !(error instanceof Locked)) {
+        throw error;
+      }
+    }
+  }
+  throw new Error("No available ports found");
+}
+
+// src/formatters/blackd.ts
 var BlackdFormatter = class extends BaseFormatter {
   constructor(pythonSettings, outputChannel) {
     super("blackd", pythonSettings, outputChannel);
     this.pythonSettings = pythonSettings;
     this.outputChannel = outputChannel;
-    this.blackdServer = null;
     this.blackdHTTPURL = "";
     this.blackdHTTPURL = this.pythonSettings.formatting.blackdHTTPURL;
     if (!this.blackdHTTPURL.length) {
-      const blackdPath = this.pythonSettings.formatting.blackdPath;
-      this.blackdServer = (0, import_child_process2.spawn)(blackdPath).on("error", (e) => {
-        this.outputChannel.appendLine("");
-        this.outputChannel.appendLine("spawn blackd HTTP server error");
-        this.outputChannel.appendLine(e.message);
-        this.outputChannel.appendLine('make sure you have installed blackd by `pip install "black[d]"`');
-        this.blackdServer = null;
-      });
+      this.lauchServer();
     }
   }
+  async lauchServer() {
+    const port = await getPorts({ port: 45484 });
+    this.blackdHTTPURL = `http://127.0.0.1:${port}`;
+    const blackdPath = this.pythonSettings.formatting.blackdPath;
+    (0, import_child_process2.spawn)(blackdPath, ["--bind-port", String(port)]).on("error", (e) => {
+      this.outputChannel.appendLine("");
+      this.outputChannel.appendLine("spawn blackd HTTP server error");
+      this.outputChannel.appendLine(e.message);
+      this.outputChannel.appendLine('make sure you have installed blackd by `pip install "black[d]"`');
+      this.blackdHTTPURL = "";
+    });
+  }
   async handle(document) {
+    if (!this.blackdHTTPURL.length) {
+      return Promise.resolve([]);
+    }
     try {
-      const _url = this.blackdHTTPURL || "http://127.0.0.1:45484";
       const headers = Object.assign({ "X-Diff": 1 }, this.pythonSettings.formatting.blackdHTTPHeaders);
-      const patch = await (0, import_coc7.fetch)(_url, { method: "POST", data: document.getText(), headers });
+      const patch = await (0, import_coc7.fetch)(this.blackdHTTPURL, { method: "POST", data: document.getText(), headers });
       this.outputChannel.appendLine("");
       this.outputChannel.appendLine(`${"#".repeat(10)} ${this.Id} output:`);
       this.outputChannel.appendLine(patch.toString());
@@ -22055,15 +22178,11 @@ var BlackdFormatter = class extends BaseFormatter {
     }
   }
   formatDocument(document, _options, _token, range) {
-    const errorMessage = async (msg) => {
+    if (range) {
+      const msg = "blackd does not support range formatting";
       this.outputChannel.appendLine(msg);
       import_coc7.window.showErrorMessage(msg);
-      return [];
-    };
-    if (range)
-      return errorMessage('Black does not support the "Format Selection" command');
-    if (!this.blackdServer && !this.blackdHTTPURL) {
-      return errorMessage("blackd server error");
+      return Promise.resolve([]);
     }
     return this.handle(document);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coc-pyright",
-  "version": "1.1.228",
+  "version": "1.1.232",
   "description": "Pyright extension for coc.nvim, static type checker for Python",
   "author": "Heyward Fann <fannheyward@gmail.com>",
   "license": "MIT",
@@ -49,6 +49,7 @@
     "esbuild": "^0.14.2",
     "eslint": "^8.4.1",
     "fs-extra": "^10.0.0",
+    "get-port": "^6.1.2",
     "iconv-lite": "^0.6.2",
     "md5": "^2.3.0",
     "named-js-regexp": "^1.3.5",
@@ -776,6 +777,17 @@
                 "error"
               ]
             },
+            "reportUnusedExpression": {
+              "type": "string",
+              "description": "Diagnostics for simple expressions whose value is not used in any way.",
+              "default": "warning",
+              "enum": [
+                "none",
+                "information",
+                "warning",
+                "error"
+              ]
+            },
             "reportUnnecessaryTypeIgnoreComment": {
               "type": "string",
               "description": "Diagnostics for '# type: ignore' comments that have no effect.",
@@ -1273,7 +1285,7 @@
         "python.formatting.blackdHTTPHeaders": {
           "type": "object",
           "default": {},
-          "description": "Custom headers POST to blackd server, checkout https://github.com/psf/black/blob/master/docs/blackd.md#protocol",
+          "description": "Custom headers POST to blackd server, checkout https://black.readthedocs.io/en/stable/usage_and_configuration/black_as_a_server.html#protocol",
           "scope": "resource"
         },
         "python.formatting.provider": {
@@ -1391,6 +1403,6 @@
     ]
   },
   "dependencies": {
-    "pyright": "^1.1.228"
+    "pyright": "^1.1.232"
   }
 }

package/schemas/pyrightconfig.schema.json

@@ -467,6 +467,12 @@
       "title": "Controls reporting of call expressions that returns Coroutine whose results are not consumed",
       "default": "error"
     },
+    "reportUnusedExpression": {
+      "$id": "#/properties/reportUnusedExpression",
+      "$ref": "#/definitions/diagnostic",
+      "title": "Controls reporting of simple expressions whose value is not used in any way",
+      "default": "warning"
+    },
     "reportUnnecessaryTypeIgnoreComment": {
       "$id": "#/properties/reportUnnecessaryTypeIgnoreComment",
       "$ref": "#/definitions/diagnostic",