Multi-errors: Capture all errors in each compilation stage

Author: Mingun

lib/compiler/index.js

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

lib/compiler/session.js

@@ -10,8 +10,8 @@ class Defaults {
     if (typeof options.warn === "function") { this.warn = options.warn; }
     if (typeof options.info === "function") { this.info = options.info; }
   }
-  error(stage, ...args) {
-    throw new GrammarError(...args);
+  error() {
+    // intentionally empty placeholder
   }
   warn() {
     // intentionally empty placeholder
@@ -24,12 +24,33 @@ 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);
   }
@@ -41,6 +62,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

@@ -230,13 +230,37 @@ 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. */
   location?: LocationRange;
   /** 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, diagnostics?: DiagnosticNote[]);
 
   /**
@@ -849,6 +873,36 @@ export interface Session {
   info(message: string, location?: LocationRange, notes?: DiagnosticNote[]): 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;
+}
+
 export interface BuildOptionsBase {
   /** rules the parser will be allowed to start parsing from (default: the first rule in the grammar) */
   allowedStartRules?: string[];
@@ -873,6 +927,13 @@ export interface BuildOptionsBase {
   plugins?: Plugin[];
   /** 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

@@ -49,6 +49,7 @@
     "@rollup/plugin-multi-entry": "^4.0.0",
     "@rollup/plugin-node-resolve": "^13.0.0",
     "@rollup/plugin-typescript": "^8.2.1",
+    "@types/chai": "^4.2.18",
     "@types/jest": "^26.0.23",
     "chai": "^4.3.4",
     "eslint": "^7.26.0",

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

@@ -1682,5 +1682,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", function() {
+      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;