Run prettier instance in worker_threads

.eslintignore

@@ -0,0 +1 @@
+/src/worker/*.js

package.json

@@ -72,13 +72,13 @@
     "lint": "eslint -c .eslintrc.js --ext .ts .",
     "pretest": "yarn test-compile && cd test-fixtures/plugins && yarn install && cd ../plugins-pnpm && pnpm i && cd ../outdated && yarn install && cd ../module && yarn install && cd ../specific-version && yarn install && cd ../explicit-dep && yarn install && cd implicit-dep && yarn install && cd ../../v3 && yarn install",
     "prettier": "prettier --write '**/*.{ts,json,md,hbs,yml,js}'",
-    "test-compile": "yarn clean && tsc -p ./ && yarn webpack",
+    "test-compile": "yarn clean && tsc -p ./ && yarn webpack && cp -r ./src/worker ./out",
     "test": "node ./out/test/runTests.js",
     "version": "node ./scripts/version.js && git add CHANGELOG.md",
     "vscode:prepublish": "webpack --mode production",
     "watch": "tsc --watch -p ./",
     "webpack-dev": "webpack --mode development --watch",
-    "webpack": "webpack --mode development",
+    "webpack": "webpack --mode development && cp -r ./src/worker ./dist",
     "postinstall": "husky install",
     "chrome": "yarn webpack && vscode-test-web --browserType=chromium --extensionDevelopmentPath=. ."
   },

src/ModuleResolver.ts

@@ -24,6 +24,7 @@ import {
   PrettierVSCodeConfig,
 } from "./types";
 import { getConfig, getWorkspaceRelativePath } from "./util";
+import { PrettierWorkerInstance } from "./PrettierWorkerInstance";
 
 const minPrettierVersion = "1.13.0";
 declare const __webpack_require__: typeof require;
@@ -69,7 +70,8 @@ function globalPathGet(packageManager: PackageManagers): string | undefined {
 export class ModuleResolver implements ModuleResolverInterface {
   private findPkgCache: Map<string, string>;
   private ignorePathCache = new Map<string, string>();
-  private path2Module = new Map<string, PrettierNodeModule>();
+
+  private path2Module = new Map<string, PrettierWorkerInstance>();
 
   constructor(private loggingService: LoggingService) {
     this.findPkgCache = new Map();
@@ -85,7 +87,7 @@ export class ModuleResolver implements ModuleResolverInterface {
    */
   public async getPrettierInstance(
     fileName: string
-  ): Promise<PrettierNodeModule | undefined> {
+  ): Promise<PrettierNodeModule | PrettierWorkerInstance | undefined> {
     if (!workspace.isTrusted) {
       this.loggingService.logDebug(UNTRUSTED_WORKSPACE_USING_BUNDLED_PRETTIER);
       return prettier;
@@ -148,7 +150,8 @@ export class ModuleResolver implements ModuleResolverInterface {
       }
     }
 
-    let moduleInstance: PrettierNodeModule | undefined = undefined;
+    let moduleInstance: PrettierWorkerInstance | undefined = undefined;
+
     if (modulePath !== undefined) {
       this.loggingService.logDebug(
         `Local prettier module path: '${modulePath}'`
@@ -159,7 +162,7 @@ export class ModuleResolver implements ModuleResolverInterface {
         return moduleInstance;
       } else {
         try {
-          moduleInstance = this.loadNodeModule<PrettierNodeModule>(modulePath);
+          moduleInstance = new PrettierWorkerInstance(modulePath);
           if (moduleInstance) {
             this.path2Module.set(modulePath, moduleInstance);
           }
@@ -178,31 +181,23 @@ export class ModuleResolver implements ModuleResolverInterface {
     }
 
     if (moduleInstance) {
-      // If the instance is missing `format`, it's probably
-      // not an instance of Prettier
-      const isPrettierInstance = !!moduleInstance.format;
-      const isValidVersion =
-        moduleInstance.version &&
-        !!moduleInstance.getSupportInfo &&
-        !!moduleInstance.getFileInfo &&
-        !!moduleInstance.resolveConfig &&
-        semver.gte(moduleInstance.version, minPrettierVersion);
-
-      if (!isPrettierInstance && prettierPath) {
+      const version = await moduleInstance.import();
+
+      if (!version && prettierPath) {
         this.loggingService.logError(INVALID_PRETTIER_PATH_MESSAGE);
         return undefined;
       }
 
+      const isValidVersion = version && semver.gte(version, minPrettierVersion);
+
       if (!isValidVersion) {
         this.loggingService.logInfo(
           `Attempted to load Prettier module from ${modulePath}`
         );
         this.loggingService.logError(OUTDATED_PRETTIER_VERSION_MESSAGE);
         return undefined;
       } else {
-        this.loggingService.logDebug(
-          `Using prettier version ${moduleInstance.version}`
-        );
+        this.loggingService.logDebug(`Using prettier version ${version}`);
       }
       return moduleInstance;
     } else {
@@ -327,6 +322,7 @@ export class ModuleResolver implements ModuleResolverInterface {
     await prettier.clearConfigCache();
     this.path2Module.forEach((module) => {
       try {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         module.clearConfigCache();
       } catch (error) {
         this.loggingService.logError("Error clearing module cache.", error);
@@ -341,19 +337,6 @@ export class ModuleResolver implements ModuleResolverInterface {
       : require;
   }
 
-  // Source: https://github.com/microsoft/vscode-eslint/blob/master/server/src/eslintServer.ts
-  private loadNodeModule<T>(moduleName: string): T | undefined {
-    try {
-      return this.nodeModuleLoader(moduleName);
-    } catch (error) {
-      this.loggingService.logError(
-        `Error loading node module '${moduleName}'`,
-        error
-      );
-    }
-    return undefined;
-  }
-
   private resolveNodeModule(moduleName: string, options?: { paths: string[] }) {
     try {
       return this.nodeModuleLoader.resolve(moduleName, options);

src/PrettierEditService.ts

@@ -25,6 +25,7 @@ import {
   RangeFormattingOptions,
 } from "./types";
 import { getConfig } from "./util";
+import { PrettierWorkerInstance } from "./PrettierWorkerInstance";
 
 interface ISelectors {
   rangeLanguageSelector: ReadonlyArray<DocumentFilter>;
@@ -252,7 +253,7 @@ export default class PrettierEditService implements Disposable {
    * Build formatter selectors
    */
   private getSelectors = async (
-    prettierInstance: PrettierModule,
+    prettierInstance: PrettierModule | PrettierWorkerInstance,
     uri?: Uri
   ): Promise<ISelectors> => {
     const { languages } = await prettierInstance.getSupportInfo();

src/PrettierWorkerInstance.ts

@@ -0,0 +1,114 @@
+import { Worker } from "worker_threads";
+import * as url from "url";
+import * as path from "path";
+import {
+  PrettierFileInfoOptions,
+  PrettierFileInfoResult,
+  PrettierOptions,
+  PrettierSupportLanguage,
+} from "./types";
+
+const worker = new Worker(
+  url.pathToFileURL(path.join(__dirname, "/worker/prettier-instance-worker.js"))
+);
+
+export class PrettierWorkerInstance {
+  private importResolver: {
+    resolve: (version: string) => void;
+    reject: (version: string) => void;
+  } | null = null;
+
+  private callMethodResolvers: {
+    id: number;
+    resolve: (value: unknown) => void;
+    reject: (value: unknown) => void;
+  }[] = [];
+
+  private currentCallMethodId = 0;
+
+  public version: string | null = null;
+
+  constructor(private modulePath: string) {
+    worker.on("message", ({ type, payload }) => {
+      switch (type) {
+        case "import": {
+          this.importResolver?.resolve(payload.version);
+          this.version = payload.version;
+          break;
+        }
+        case "callMethod": {
+          const resolver = this.callMethodResolvers.find(({ id }) => {
+            return id === payload.id;
+          });
+          if (resolver) {
+            if (payload.isError) {
+              resolver.reject(payload.result);
+            } else {
+              resolver.resolve(payload.result);
+            }
+          }
+          break;
+        }
+      }
+    });
+  }
+
+  public async import(): Promise</* version of imported prettier */ string> {
+    const promise = new Promise<string>((resolve, reject) => {
+      this.importResolver = { resolve, reject };
+    });
+    worker.postMessage({
+      type: "import",
+      payload: { modulePath: this.modulePath },
+    });
+    return promise;
+  }
+
+  public async format(
+    source: string,
+    options?: PrettierOptions
+  ): Promise<string> {
+    const result = this.callMethod("format", [source, options]);
+    return result;
+  }
+
+  public async getSupportInfo(): Promise<{
+    languages: PrettierSupportLanguage[];
+  }> {
+    const result = await this.callMethod("getSupportInfo", []);
+    return result;
+  }
+
+  public async clearConfigCache(): Promise<void> {
+    await this.callMethod("clearConfigCache", []);
+  }
+
+  public async getFileInfo(
+    filePath: string,
+    fileInfoOptions?: PrettierFileInfoOptions
+  ): Promise<PrettierFileInfoResult> {
+    const result = await this.callMethod("getFileInfo", [
+      filePath,
+      fileInfoOptions,
+    ]);
+    return result;
+  }
+
+  private callMethod(methodName: string, methodArgs: unknown[]): Promise<any> {
+    const callMethodId = this.currentCallMethodId++;
+    // log(JSON.stringify({ methodName, methodArgs, callMethodId }));
+    const promise = new Promise((resolve, reject) => {
+      this.callMethodResolvers.push({ id: callMethodId, resolve, reject });
+    });
+    worker.postMessage({
+      type: "callMethod",
+      payload: {
+        id: callMethodId,
+        modulePath: this.modulePath,
+        methodName,
+        methodArgs,
+      },
+    });
+    return promise;
+  }
+}

src/test/suite/format.test.ts

@@ -54,7 +54,11 @@ export function putBackPrettierRC(done: Done) {
  * @param base base URI
  * @returns source code and resulting code
  */
-export async function format(workspaceFolderName: string, testFile: string) {
+export async function format(
+  workspaceFolderName: string,
+  testFile: string,
+  shouldRetry = false
+) {
   const base = getWorkspaceFolderUri(workspaceFolderName);
   const absPath = path.join(base.fsPath, testFile);
   const doc = await vscode.workspace.openTextDocument(absPath);
@@ -70,10 +74,23 @@ export async function format(workspaceFolderName: string, testFile: string) {
   console.time(testFile);
   await vscode.commands.executeCommand("editor.action.formatDocument");
 
+  let actual = doc.getText();
+
+  if (shouldRetry) {
+    for (let i = 0; i < 10; i++) {
+      if (text !== actual) {
+        break;
+      }
+      await wait(150);
+      await vscode.commands.executeCommand("editor.action.formatDocument");
+      actual = doc.getText();
+    }
+  }
+
   // eslint-disable-next-line no-console
   console.timeEnd(testFile);
 
-  return { actual: doc.getText(), source: text };
+  return { actual, source: text };
 }
 /**
  * Compare prettier's output (default settings)

src/test/suite/module.test.ts

@@ -17,7 +17,11 @@ suite("Test module resolution", function () {
   });
 
   test("it loads plugin referenced in dependency module", async () => {
-    const { actual } = await format("module-plugin", "index.js");
+    const { actual } = await format(
+      "module-plugin",
+      "index.js",
+      /* shouldRetry */ true
+    );
     const expected = await getText("module-plugin", "index.result.js");
     assert.equal(actual, expected);
   });

src/test/suite/plugins.test.ts

@@ -4,7 +4,11 @@ import { format, getText } from "./format.test";
 suite("Test plugins", function () {
   this.timeout(10000);
   test("it formats with plugins", async () => {
-    const { actual } = await format("plugins", "index.php");
+    const { actual } = await format(
+      "plugins",
+      "index.php",
+      /* shouldRetry */ true
+    );
     const expected = await getText("plugins", "index.result.php");
     assert.equal(actual, expected);
   });

src/types.d.ts

@@ -1,5 +1,6 @@
 import * as prettier from "prettier";
 import { TextDocument } from "vscode";
+import { PrettierWorkerInstance } from "./PrettierWorkerInstance";
 
 type PrettierSupportLanguage = {
   vscodeLanguageIds?: string[];
@@ -25,7 +26,9 @@ type PrettierModule = {
 };
 
 type ModuleResolverInterface = {
-  getPrettierInstance(fileName: string): Promise<PrettierModule | undefined>;
+  getPrettierInstance(
+    fileName: string
+  ): Promise<PrettierModule | PrettierWorkerInstance | undefined>;
   getResolvedIgnorePath(
     fileName: string,
     ignorePath: string