libexpr: diagnostics framework & error recovery basics

Author: inclyc

src/libexpr/diagnostic.hh

@@ -0,0 +1,220 @@
+/// diagnostic.hh - This file declares records that related to nix diagnostic
+///
+/// Diagnostics are structures with a main message,
+/// and optionally some additional information (body).
+///
+/// For diagnostics with a body,
+/// they may need a special overrided function to format the message.
+///
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "error.hh"
+#include "nixexpr.hh"
+
+namespace nix {
+
+/**
+ * The base class for all diagnostics.
+ * concret diagnostic types are defined in Diagnostic*.inc
+ */
+struct Diag
+{
+    /**
+     * The location of some diagnostic, currently it is at the beginning of tokens
+     */
+    PosIdx loc;
+
+    /**
+     * Unique identifier for internal use.
+     */
+    enum Kind {
+#define DIAG_MERGE(SNAME, CNAME, SEVERITY, MESSAGE) DK_##CNAME,
+#include "diagnostics/merge.inc"
+    };
+
+    Diag() = default;
+    Diag(PosIdx loc)
+        : loc(loc){};
+
+    /**
+     * Each diagnostic contains a severity field,
+     * should be "Fatal", "Error" or "Warning"
+     * this will affect the eval process.
+     *
+     * "Fatal"   -- non-recoverable while parsing.
+     * "Error"   -- recoverable while parsing, but should not eval
+     * "Warning" -- recoverable while parsing, and we can eval the AST
+     * "Note"    -- some additional information about the error.
+     */
+    enum Severity { DS_Fatal, DS_Error, DS_Warning, DS_Note };
+
+    [[nodiscard]] virtual Kind kind() const = 0;
+
+    /**
+     * \brief short name.
+     * There might be a human readable short name that controls the diagnostic
+     * For example, one may pass -Wno-dup-formal to suppress duplicated formals.
+     * A special case for parsing errors, generated from bison
+     * have the sname "bison"
+     */
+    [[nodiscard]] virtual std::string_view sname() const = 0;
+
+    /** Get severity */
+    [[nodiscard]] virtual Severity severity() const = 0;
+
+    /**
+     * Format printable diagnostic, with string interpolated
+     * e.g. "invalid integer %1%" -> "invalid integer 'bar'"
+     */
+    [[nodiscard]] virtual std::string_view format() const = 0;
+
+    virtual ~Diag() = default;
+
+    static Verbosity getVerb(Severity s)
+    {
+        switch (s) {
+        case DS_Error:
+        case DS_Fatal:
+            return lvlError;
+        case DS_Warning:
+            return lvlWarn;
+        case DS_Note:
+            return lvlNotice;
+        }
+    }
+
+    [[nodiscard]] ErrorInfo getErrorInfo(const PosTable & positions) const
+    {
+        return ErrorInfo{.msg = std::string(format()), .errPos = positions[loc]};
+    }
+
+    using Notes = std::vector<std::shared_ptr<Diag>>;
+
+    [[nodiscard]] virtual Notes getNotes() const
+    {
+        return {};
+    }
+};
+
+struct DiagWithNotes : Diag
+{
+    Diag::Notes notes;
+    [[nodiscard]] Diag::Notes getNotes() const override
+    {
+        return notes;
+    }
+};
+
+#define DIAG_SIMPLE(SNAME, CNAME, SEVERITY, MESSAGE) \
+    struct Diag##CNAME : Diag \
+    { \
+        std::string_view format() const override \
+        { \
+            return MESSAGE; \
+        } \
+        std::string_view sname() const override \
+        { \
+            return SNAME; \
+        } \
+        Severity severity() const override \
+        { \
+            return DS_##SEVERITY; \
+        } \
+        Kind kind() const override \
+        { \
+            return DK_##CNAME; \
+        } \
+        Diag##CNAME() = default; \
+        Diag##CNAME(PosIdx pos) \
+            : Diag(pos) \
+        { \
+        } \
+    };
+#include "diagnostics/kinds.inc"
+#undef DIAG_SIMPLE
+
+#define DIAG_BODY(SNAME, CNAME, SEVERITY, MESSAGE, BODY) struct Diag##CNAME : Diag BODY;
+#include "diagnostics/kinds.inc"
+#undef DIAG_BODY
+
+// Implement trivial functions except ::format
+#define DIAG_BODY(SNAME, CNAME, SEVERITY, MESSAGE, BODY) \
+    inline std::string_view Diag##CNAME::sname() const \
+    { \
+        return SNAME; \
+    } \
+    inline Diag::Severity Diag##CNAME::severity() const \
+    { \
+        return DS_##SEVERITY; \
+    } \
+    inline Diag::Kind Diag##CNAME::kind() const \
+    { \
+        return DK_##CNAME; \
+    }
+#include "diagnostics/kinds.inc"
+#undef DIAG_BODY
+
+inline DiagInvalidInteger::DiagInvalidInteger(PosIdx loc, std::string text)
+    : Diag(loc)
+    , text(std::move(text))
+{
+}
+
+inline DiagInvalidFloat::DiagInvalidFloat(PosIdx loc, std::string text)
+    : Diag(loc)
+    , text(std::move(text))
+{
+}
+
+inline std::string_view DiagInvalidInteger::format() const
+{
+    return text;
+}
+
+inline std::string_view DiagInvalidFloat::format() const
+{
+    return text;
+}
+
+inline std::string_view DiagBisonParse::format() const
+{
+    return err;
+}
+
+struct DiagnosticEngine
+{
+    std::vector<std::unique_ptr<Diag>> errors;
+    std::vector<std::unique_ptr<Diag>> warnings;
+
+    void add(std::unique_ptr<Diag> D)
+    {
+        switch (D->severity()) {
+        case Diag::DS_Fatal:
+        case Diag::DS_Error: {
+            errors.emplace_back(std::move(D));
+            break;
+        }
+        case Diag::DS_Warning: {
+            warnings.emplace_back(std::move(D));
+            break;
+        }
+        case Diag::DS_Note: {
+            // todo: unreachble
+            assert(0);
+        }
+        }
+    }
+
+    void checkRaise(const PosTable & positions) const
+    {
+        if (!errors.empty()) {
+            const Diag * back = errors[0].get();
+            throw ParseError(back->getErrorInfo(positions));
+        }
+    }
+};
+
+} // namespace nix

src/libexpr/diagnostics/kinds.inc

@@ -0,0 +1,49 @@
+/// diagnostics/kinds.inc, provides declarations for diagnostics.
+
+// provides: DIAG_SIMPLE(SNAME, CNAME, SEVERITY, MESSAGE)
+// provides: DIAG_BODY(SNAME, CNAME, SEVERITY, MESSAGE, BODY)
+// provides: DIAG_NOTE_SIMPLE(SNAME, CNAME, SEVERITY, MESSAGE)
+// provides: DIAG_NOTE_BODY(SNAME, CNAME, SEVERITY, MESSAGE, BODY)
+
+//=============================================================================/
+// DIAG_SIMPLE(SName, ClassName, Severity, Message)
+// "simple" means they have no additional body
+//=============================================================================/
+
+#ifdef DIAG_SIMPLE
+DIAG_SIMPLE("path-trailing-slash", PathTrailingSlash, Error, "path has a trailing slash")
+DIAG_SIMPLE("dynamic-in-let", DynamicInLet, Error, "dynamic attributes not allowed in let")
+DIAG_SIMPLE("dynamic-in-inherit", InheritDynamic, Error, "dynamic attributes not allowed in inherit")
+DIAG_SIMPLE("url-literal", URLLiteral, Warning, "url literals are disabled")
+DIAG_SIMPLE("hpath-impure", HPath, Error, "hpath cannot be resolved in pure mode")
+#endif
+
+#define COMMON_METHOD \
+    Severity severity() const override; \
+    Kind kind() const override; \
+    std::string_view format() const override; \
+    std::string_view sname() const override;
+
+//=============================================================================/
+// DIAG_BODY(SName, ClassName, Severity, Message, Body)
+// diagnostics with special body
+//=============================================================================/
+#ifdef DIAG_BODY
+DIAG_BODY("bison", BisonParse, Fatal, "", {
+    std::string err;
+    COMMON_METHOD
+})
+DIAG_BODY("invalid-integer", InvalidInteger, Fatal, "", {
+    std::string text;
+    COMMON_METHOD
+    DiagInvalidInteger(PosIdx loc, std::string text);
+})
+
+DIAG_BODY("invalid-float", InvalidFloat, Fatal, "", {
+    std::string text;
+    COMMON_METHOD
+    DiagInvalidFloat(PosIdx loc, std::string text);
+})
+
+#undef COMMON_METHOD
+#endif // DIAG_BODY

src/libexpr/diagnostics/merge.inc

@@ -0,0 +1,17 @@
+// diagnostics/merge.inc, merge all declarations
+
+// provides: DIAG_MERGE(SNAME, CNAME, SEVERITY, MESSAGE)
+
+#ifdef DIAG_MERGE
+
+#define DIAG_SIMPLE(SNAME, CNAME, SEVERITY, MESSAGE) DIAG_MERGE(SNAME, CNAME, SEVERITY, MESSAGE)
+#define DIAG_BODY(SNAME, CNAME, SEVERITY, MESSAGE, BODY) DIAG_MERGE(SNAME, CNAME, SEVERITY, MESSAGE)
+#define DIAG_NOTE_SIMPLE(SNAME, CNAME, SEVERITY, MESSAGE) DIAG_MERGE(SNAME, CNAME, SEVERITY, MESSAGE)
+
+#include "kinds.inc"
+
+#undef DIAG_NOTE_SIMPLE
+#undef DIAG_BODY
+#undef DIAG_SIMPLE
+
+#endif

src/libexpr/lexer/lexer.l

@@ -62,20 +62,17 @@ or          { return OR_KW; }
               try {
                   yylval->n = boost::lexical_cast<int64_t>(yytext);
               } catch (const boost::bad_lexical_cast &) {
-                  throw ParseError({
-                      .msg = hintfmt("invalid integer '%1%'", yytext),
-                      .errPos = data->state.positions[CUR_POS],
-                  });
+                  data->diags.add(std::make_unique<DiagInvalidInteger>(CUR_POS, yytext));
+                  yyterminate();
               }
               return INT;
             }
 {FLOAT}     { errno = 0;
               yylval->nf = strtod(yytext, 0);
-              if (errno != 0)
-                  throw ParseError({
-                      .msg = hintfmt("invalid float '%1%'", yytext),
-                      .errPos = data->state.positions[CUR_POS],
-                  });
+              if (errno != 0) {
+                  data->diags.add(std::make_unique<DiagInvalidFloat>(CUR_POS, yytext));
+                  yyterminate();
+              }
               return FLOAT;
             }
 
@@ -201,10 +198,8 @@ or          { return OR_KW; }
 
 <INPATH_SLASH>{ANY} |
 <INPATH_SLASH><<EOF>> {
-  throw ParseError({
-      .msg = hintfmt("path has a trailing slash"),
-      .errPos = data->state.positions[CUR_POS],
-  });
+  data->diags.add(std::make_unique<DiagPathTrailingSlash>(CUR_POS));
+  yyterminate();
 }
 
 {SPATH}     { yylval->path = {yytext, (size_t) yyleng}; return SPATH; }

src/libexpr/parser/epilogue.inc

@@ -30,11 +30,10 @@ Expr * EvalState::parse(
 
     yylex_init(&scanner);
     yy_scan_buffer(text, length, scanner);
-    int res = yyparse(scanner, &data);
+    yyparse(scanner, &data);
     yylex_destroy(scanner);
 
-    if (res)
-        throw ParseError(data.error.value());
+    data.diags.checkRaise(data.state.positions);
 
     data.result->bindVars(*this, staticEnv);
 

src/libexpr/parser/parser.y

@@ -97,11 +97,10 @@ expr_function
   | WITH expr ';' expr_function
     { $$ = new ExprWith(CUR_POS, $2, $4); }
   | LET binds IN expr_function
-    { if (!$2->dynamicAttrs.empty())
-        throw ParseError({
-            .msg = hintfmt("dynamic attributes not allowed in let"),
-            .errPos = data->state.positions[CUR_POS]
-        });
+    {
+      if (!$2->dynamicAttrs.empty()) {
+        data->diags.add(std::make_unique<DiagDynamicInLet>(CUR_POS));
+      }
       $$ = new ExprLet($2, $4);
     }
   | expr_if
@@ -186,12 +185,7 @@ expr_simple
            new ExprString(std::move(path))});
   }
   | URI {
-      static bool noURLLiterals = experimentalFeatureSettings.isEnabled(Xp::NoUrlLiterals);
-      if (noURLLiterals)
-          throw ParseError({
-              .msg = hintfmt("URL literals are disabled"),
-              .errPos = data->state.positions[CUR_POS]
-          });
+      data->diags.add(std::make_unique<DiagURLLiteral>(CUR_POS));
       $$ = new ExprString(std::string($1));
   }
   | '(' expr ')' { $$ = $2; }
@@ -234,10 +228,7 @@ path_start
   }
   | HPATH {
     if (evalSettings.pureEval) {
-        throw Error(
-            "the path '%s' can not be resolved in pure mode",
-            std::string_view($1.p, $1.l)
-        );
+        data->diags.add(std::make_unique<DiagHPath>(CUR_POS));
     }
     Path path(getHome() + std::string($1.p + 1, $1.l - 1));
     $$ = new ExprPath(std::move(path));
@@ -284,10 +275,7 @@ attrs
           $$->push_back(AttrName(data->symbols.create(str->s)));
           delete str;
       } else
-          throw ParseError({
-              .msg = hintfmt("dynamic attributes not allowed in inherit"),
-              .errPos = data->state.positions[makeCurPos(@2, data)]
-          });
+          data->diags.add(std::make_unique<DiagInheritDynamic>(CUR_POS));
     }
   | { $$ = new AttrPath; }
   ;