wasm: share Process between DocumentLinter-s

Allow a single WebAssembly memory space (Process) to hold multiple
DocumentForVSCode objects through DocumentLinter/DocumentProcessManager.
This has a few benefits:

* reduced memory usage (minor)
* shared caches (minor)
* unlock future changes, such as sharing a configuration between
  multiple .js files

Untested: crash tolerance in the presence of multiple documents being
changed concurrenly. There are likely bugs.

This commit does not affect the VS Code extension because it currently
uses one DocumentProcessManager per DocumentLinter.

Author: strager

wasm/quick-lint-js.js

@@ -71,9 +71,8 @@ class DocumentLinter {
     this._parserPromise = (async () => {
       let parser;
       try {
-        let factory = await this._documentProcessManager._processFactoryPromise;
-        // TODO(strager): Reuse processes across documents.
-        let process = await factory.createProcessAsync();
+        let process =
+          await this._documentProcessManager.getOrCreateProcessAsync();
         parser = await process.createDocumentForVSCodeAsync();
       } catch (e) {
         if (e instanceof ProcessCrashed) {
@@ -268,9 +267,10 @@ class DocumentLinter {
     this._recoveryPromise = (async () => {
       let diags;
       try {
-        // TODO(strager): Reuse processes across documents.
-        let factory = await this._documentProcessManager._processFactoryPromise;
-        let process = await factory.createProcessAsync();
+        let process =
+          await this._documentProcessManager.getOrCreateDifferentProcessAsync(
+            this._parser.process
+          );
         let parser = await process.createDocumentForVSCodeAsync();
 
         // BEGIN CRITICAL SECTION (no awaiting below)
@@ -310,6 +310,47 @@ class DocumentProcessManager {
   constructor() {
     // TODO(strager): Allow developers to reload the .wasm file.
     this._processFactoryPromise = createProcessFactoryAsync();
+    this._processesCreated = 0;
+    this._processPromise = null;
+    this._process = null;
+  }
+
+  async createNewProcessAsync() {
+    let processFactory = await this._processFactoryPromise;
+    let process = await processFactory.createProcessAsync();
+    this._processesCreated += 1;
+    this._process = process;
+    return process;
+  }
+
+  async getOrCreateProcessAsync() {
+    // BEGIN CRITICAL SECTION (no awaiting below)
+    if (this._processPromise === null) {
+      this._processPromise = this.createNewProcessAsync();
+      // END CRITICAL SECTION (no awaiting above)
+    }
+    return await this._processPromise;
+  }
+
+  async getOrCreateDifferentProcessAsync(existingProcess) {
+    if (!(existingProcess instanceof Process)) {
+      throw new TypeError(`Expected Process, but got ${existingProcess}`);
+    }
+    if (this._process !== existingProcess) {
+      return this._process;
+    }
+    this._forgetCurrentProcess();
+    return await this.getOrCreateProcessAsync();
+  }
+
+  _forgetCurrentProcess() {
+    this._process = null;
+    this._processPromise = null;
+  }
+
+  // For testing only.
+  get numberOfProcessesEverCreated() {
+    return this._processesCreated;
   }
 }
 exports.DocumentProcessManager = DocumentProcessManager;
@@ -550,6 +591,10 @@ class DocumentForVSCode {
     this._process._vscodeDestroyDocument(this._parser);
     this._parser = null;
   }
+
+  get process() {
+    return this._process;
+  }
 }
 
 class DocumentForWebDemo {

wasm/test-document.js

@@ -369,6 +369,70 @@ describe("DocumentLinter", () => {
       crashedProcesses.clear(); // Avoid out-of-memory errors.
     }
   }, /*timeout=*/ 60_000);
+
+  it("multiple documents with shared process manager lint independently", async () => {
+    let documentProcessManager = new DocumentProcessManager();
+    let document1 = new MockDocument("let x;let x;");
+    let linter1 = disposeAfterTest(
+      new DocumentLinter(document1, documentProcessManager)
+    );
+    let document2 = new MockDocument("let y;let y;");
+    let linter2 = disposeAfterTest(
+      new DocumentLinter(document2, documentProcessManager)
+    );
+
+    await linter1.editorChangedVisibilityAsync();
+    assert.deepStrictEqual(document1.getDiagnosticMessages(), [
+      "redeclaration of variable: x",
+    ]);
+
+    await linter2.editorChangedVisibilityAsync();
+    assert.deepStrictEqual(document1.getDiagnosticMessages(), [
+      "redeclaration of variable: x",
+    ]);
+    assert.deepStrictEqual(document2.getDiagnosticMessages(), [
+      "redeclaration of variable: y",
+    ]);
+
+    document1.text = "let x;let x2;";
+    await linter1.textChangedAsync([
+      {
+        range: {
+          start: { line: 0, character: "let x;let x".length },
+          end: { line: 0, character: "let x;let x".length },
+        },
+        text: "2",
+      },
+    ]);
+    assert.deepStrictEqual(document1.getDiagnosticMessages(), []);
+    assert.deepStrictEqual(document2.getDiagnosticMessages(), [
+      "redeclaration of variable: y",
+    ]);
+
+    document2.text = "let z;let z;";
+    await linter2.textChangedAsync([
+      {
+        range: {
+          start: { line: 0, character: "let ".length },
+          end: { line: 0, character: "let y".length },
+        },
+        text: "z",
+      },
+      {
+        range: {
+          start: { line: 0, character: "let z;let ".length },
+          end: { line: 0, character: "let z;let y".length },
+        },
+        text: "z",
+      },
+    ]);
+    assert.deepStrictEqual(document1.getDiagnosticMessages(), []);
+    assert.deepStrictEqual(document2.getDiagnosticMessages(), [
+      "redeclaration of variable: z",
+    ]);
+
+    assert.strictEqual(documentProcessManager.numberOfProcessesEverCreated, 1);
+  });
 });
 
 describe("ExhaustiveRNG", () => {