Error classname as name

src/error-demo/error-demo.cc

@@ -4,10 +4,12 @@
 #include <iostream>
 #include <optional>
 
+using namespace nix;
+
+MakeError(DemoError, Error);
+
 int main()
 {
-    using namespace nix;
-
     makeDefaultLogger();
 
     verbosity = lvlVomit;
@@ -15,6 +17,12 @@ int main()
     // In each program where errors occur, this has to be set.
     ErrorInfo::programName = std::optional("error-demo");
 
+    try {
+        throw DemoError("demo error was thrown");
+    } catch (Error &e) {
+        logger->logEI(e.info());
+    }
+
     // For completeness sake, info through vomit levels.
     // But this is maybe a heavy format for those.
     logger->logEI(

src/libstore/sqlite.cc

@@ -196,7 +196,7 @@ SQLiteTxn::~SQLiteTxn()
     }
 }
 
-void handleSQLiteBusy(const SQLiteBusy & e)
+void handleSQLiteBusy(SQLiteBusy & e)
 {
     static std::atomic<time_t> lastWarned{0};
 

src/libstore/sqlite.hh

@@ -99,7 +99,7 @@ MakeError(SQLiteBusy, SQLiteError);
 
 [[noreturn]] void throwSQLiteError(sqlite3 * db, const FormatOrString & fs);
 
-void handleSQLiteBusy(const SQLiteBusy & e);
+void handleSQLiteBusy(SQLiteBusy & e);
 
 /* Convenience function for retrying a SQLite transaction when the
    database is busy. */

src/libutil/error.cc

@@ -4,8 +4,7 @@
 #include <optional>
 #include "serialise.hh"
 
-namespace nix
+namespace nix {
-{
 
 
 const std::string nativeSystem = SYSTEM;

src/libutil/error.hh

@@ -24,8 +24,7 @@ namespace nix {
 using std::list;
 using std::vector;
 
-typedef enum
+typedef enum {
-{
     lvlError = 0,
     lvlWarn,
     lvlInfo,
@@ -35,8 +34,7 @@ typedef enum
     lvlVomit
 } Verbosity;
 
-struct ErrPos
+struct ErrPos {
-{
     int line;
     int column;
     string file;
@@ -57,8 +55,7 @@ struct ErrPos
     }
 };
 
-struct NixCode
+struct NixCode {
-{
     ErrPos errPos;
     std::optional<string> prevLineOfCode;
     string errLineOfCode;
@@ -67,8 +64,7 @@ struct NixCode
 
 // -------------------------------------------------
 // ErrorInfo.
-struct ErrorInfo
+struct ErrorInfo {
-{
     Verbosity level;
     string name;
     string description;
@@ -87,12 +83,20 @@ class BaseError : public std::exception
 protected:
     string prefix_; // used for location traces etc.
     ErrorInfo err;
-    string what_;
+    std::optional<string> what_;
-    void initWhat()
+    const string& calcWhat()
     {
+        if (what_.has_value())
+            return *what_;
+        else {
+            err.name = sname();
+
             std::ostringstream oss;
             oss << err;
             what_ = oss.str();
+
+            return *what_;
+        }
     }
 public:
     unsigned int status = 1; // exit status
@@ -103,31 +107,33 @@ public:
                 .hint = hintfmt(args...)
               }
         , status(status)
-    { initWhat(); }
+    {  }
 
     template<typename... Args>
     BaseError(const Args & ... args)
         : err { .level = lvlError,
                 .hint = hintfmt(args...)
               }
-    { initWhat(); }
+    {  }
 
     BaseError(ErrorInfo e)
         : err(e)
-    { initWhat(); }
+    {  }
+
+    virtual const char* sname() const { return "BaseError"; }
 
 #ifdef EXCEPTION_NEEDS_THROW_SPEC
     ~BaseError() throw () { };
-    const char * what() const throw () { return what_.c_str(); }
+    const char * what() throw () { return calcWhat().c_str(); }
 #else
-    const char * what() const noexcept { return what_.c_str(); }
+    const char * what() noexcept { return calcWhat().c_str(); }
 #endif
 
-    const string & msg() const { return what_; }
+    const string & msg() { return calcWhat(); }
     const string & prefix() const { return prefix_; }
     BaseError & addPrefix(const FormatOrString & fs);
 
-    const ErrorInfo & info() const { return err; }
+    const ErrorInfo & info() { calcWhat(); return err; }
 };
 
 #define MakeError(newClass, superClass) \
@@ -135,6 +141,7 @@ public:
     {                                                   \
     public:                                             \
         using superClass::superClass;                   \
+        virtual const char* sname() const override { return #newClass; } \
     }
 
 MakeError(Error, BaseError);