Multi-errors: Capture all errors in each compilation stage

Author: Mingun

lib/compiler/index.js

@@ -98,6 +98,9 @@ const compiler = {
 
         pass(ast, options, session);
       });
+
+      // Collect all errors by stage
+      session.checkErrors();
     });
 
     switch (options.output) {

lib/compiler/session.js

@@ -11,8 +11,8 @@ class Defaults {
     if (typeof options.info === "function") { this.info = options.info; }
   }
 
-  error(stage, ...args) {
-    throw new GrammarError(...args);
+  error() {
+    // Intentionally empty placeholder
   }
 
   warn() {
@@ -27,13 +27,34 @@ class Defaults {
 class Session {
   constructor(options) {
     this._callbacks = new Defaults(options);
+    this._firstError = null;
     this.errors = 0;
     this.problems = [];
     this.stage = null;
   }
 
   error(...args) {
     ++this.errors;
+    // In order to preserve backward compatibility we cannot change `GrammarError`
+    // constructor, nor throw another class of error:
+    // - if we change `GrammarError` constructor, this will break plugins that
+    //   throws `GrammarError`
+    // - if we throw another Error class, this will break parser clients that
+    //   catches GrammarError
+    //
+    // So we use a compromise: we throw an `GrammarError` with all found problems
+    // in the `problems` property, but the thrown error itself is the first
+    // registered error.
+    //
+    // Thus when the old client catches the error it can find all properties on
+    // the Grammar error that it want. On the other hand the new client can
+    // inspect the `problems` property to get all problems.
+    if (this._firstError === null) {
+      this._firstError = new GrammarError(...args);
+      this._firstError.stage = this.stage;
+      this._firstError.problems = this.problems;
+    }
+
     this.problems.push(["error", ...args]);
     this._callbacks.error(this.stage, ...args);
   }
@@ -47,6 +68,12 @@ class Session {
     this.problems.push(["info", ...args]);
     this._callbacks.info(this.stage, ...args);
   }
+
+  checkErrors() {
+    if (this.errors !== 0) {
+      throw this._firstError;
+    }
+  }
 }
 
 module.exports = Session;

lib/grammar-error.js

@@ -27,6 +27,10 @@ class GrammarError extends Error {
       diagnostics = [];
     }
     this.diagnostics = diagnostics;
+    // All problems if this error is thrown by the plugin and not at stage
+    // checking phase
+    this.stage = null;
+    this.problems = [["error", message, location, diagnostics]];
   }
 
   toString() {

lib/peg.d.ts

@@ -266,6 +266,22 @@ export interface DiagnosticNote {
   location: LocationRange;
 }
 
+/** Possible compilation stage name. */
+type Stage = keyof Stages;
+/** Severity level of problems that can be registered in compilation session. */
+type Severity = "error" | "warn" | "info";
+
+type Problem = [
+  /** Problem severity. */
+  Severity,
+  /** Diagnostic message. */
+  string,
+  /** Location where message is generated, if applicable. */
+  LocationRange?,
+  /** List of additional messages with their locations, if applicable. */
+  DiagnosticNote[]?,
+];
+
 /** Thrown if the grammar contains a semantic error. */
 export class GrammarError extends Error {
   /** Location of the error in the source. */
@@ -274,6 +290,15 @@ export class GrammarError extends Error {
   /** Additional messages with context information. */
   diagnostics: DiagnosticNote[];
 
+  /** Compilation stage during which error was generated. */
+  stage: Stage | null;
+
+  /**
+   * List of diagnostics containing all errors, warnings and information
+   * messages generated during compilation stage `stage`.
+   */
+  problems: Problem[];
+
   constructor(
     message: string,
     location?: LocationRange,
@@ -919,6 +944,51 @@ export interface Session {
   ): void;
 }
 
+export interface DiagnosticCallback {
+  /**
+   * Called when compiler reports an error.
+   *
+   * @param stage Stage in which this diagnostic was originated
+   * @param message Main message, which should describe error objectives
+   * @param location If defined, this is location described in the `message`
+   * @param notes Additional messages with context information
+   */
+  error?(
+    stage: Stage,
+    message: string,
+    location?: LocationRange,
+    notes?: DiagnosticNote[]
+  ): void;
+  /**
+   * Called when compiler reports a warning.
+   *
+   * @param stage Stage in which this diagnostic was originated
+   * @param message Main message, which should describe warning objectives
+   * @param location If defined, this is location described in the `message`
+   * @param notes Additional messages with context information
+   */
+  warn?(
+    stage: Stage,
+    message: string,
+    location?: LocationRange,
+    notes?: DiagnosticNote[]
+  ): void;
+  /**
+   * Called when compiler reports an informational message.
+   *
+   * @param stage Stage in which this diagnostic was originated
+   * @param message Main message, which gives information about an event
+   * @param location If defined, this is location described in the `message`
+   * @param notes Additional messages with context information
+   */
+  info?(
+    stage: Stage,
+    message: string,
+    location?: LocationRange,
+    notes?: DiagnosticNote[]
+  ): void;
+}
+
 /**
  * Parser dependencies, is an object which maps variables used to access the
  * dependencies in the parser to module IDs used to load them
@@ -956,6 +1026,13 @@ export interface BuildOptionsBase {
 
   /** Makes the parser trace its progress (default: `false`) */
   trace?: boolean;
+
+  /** Called when a semantic error during build was detected. */
+  error?: DiagnosticCallback;
+  /** Called when a warning during build was registered. */
+  warn?: DiagnosticCallback;
+  /** Called when an informational message during build was registered. */
+  info?: DiagnosticCallback;
 }
 
 export interface ParserBuildOptions extends BuildOptionsBase {

package.json

@@ -52,6 +52,7 @@
     "@rollup/plugin-multi-entry": "^4.1.0",
     "@rollup/plugin-node-resolve": "^13.0.4",
     "@rollup/plugin-typescript": "^8.2.5",
+    "@types/chai": "^4.2.18",
     "@types/jest": "^26.0.24",
     "@types/node": "^16.6.1",
     "@typescript-eslint/eslint-plugin": "^4.29.1",

test/behavior/generated-parser-behavior.spec.js

@@ -1780,5 +1780,36 @@ Error: Expected "{", code block, comment, end of line, identifier, or whitespace
         }
       }).to.throw(peg.parser.SyntaxError);
     });
+
+    it("reports multiply errors in each compilation stage", () => {
+      try {
+        peg.generate(`
+          start = leftRecursion
+          leftRecursion = duplicatedLabel:duplicatedRule duplicatedLabel:missingRule
+          duplicatedRule = missingRule
+          duplicatedRule = start
+        `);
+      } catch (e) {
+        expect(e).with.property("stage", "check");
+        expect(e).with.property("problems").to.be.an("array");
+
+        // Check that each problem is an array with at least two members and the first is a severity
+        e.problems.forEach(problem => {
+          expect(problem).to.be.an("array").lengthOf.gte(2);
+          expect(problem[0]).to.be.oneOf(["error", "warn", "info"]);
+        });
+
+        // Get second elements of errors (error messages)
+        const messages = e.problems.filter(p => p[0] === "error").map(p => p[1]);
+
+        // Check that all messages present in the list
+        expect(messages).to.include.members([
+          "Rule \"missingRule\" is not defined",
+          "Rule \"duplicatedRule\" is already defined",
+          "Label \"duplicatedLabel\" is already defined",
+          "Possible infinite loop when parsing (left recursion: duplicatedRule -> start -> leftRecursion -> duplicatedRule)",
+        ]);
+      }
+    });
   });
 });

test/unit/compiler/passes/helpers.js

@@ -1,5 +1,6 @@
 "use strict";
 
+const { GrammarError } = require("../../../../lib/peg");
 const parser = require("../../../../lib/parser");
 const Session = require("../../../../lib/compiler/session");
 
@@ -47,7 +48,9 @@ module.exports = function(chai, utils) {
 
     const ast = parser.parse(grammar);
 
-    utils.flag(this, "object")(ast, options, new Session());
+    utils.flag(this, "object")(ast, options, new Session({
+      error(stage, ...args) { throw new GrammarError(...args); },
+    }));
 
     this.assert(
       matchProps(ast, props),
@@ -64,7 +67,9 @@ module.exports = function(chai, utils) {
     let passed, result;
 
     try {
-      utils.flag(this, "object")(ast, {}, new Session());
+      utils.flag(this, "object")(ast, {}, new Session({
+        error(stage, ...args) { throw new GrammarError(...args); },
+      }));
       passed = true;
     } catch (e) {
       result = e;

test/unit/grammar-error.spec.js

@@ -1,7 +1,7 @@
 "use strict";
 
 const chai = require("chai");
-const GrammarError = require("../../lib/grammar-error");
+const { GrammarError } = require("../../lib/peg");
 
 const expect = chai.expect;