error.hh

Go to the documentation of this file.

#pragma once
#include "lix/libutil/json-fwd.hh"
#include "lix/libutil/suggestions.hh"
#include "lix/libutil/fmt.hh"
 
#include <cstring>
#include <list>
#include <memory>
#include <optional>
 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <system_error>
#include <type_traits>
 
namespace nix {
 
 
typedef enum {
    lvlError = 0,
    lvlWarn,
    lvlNotice,
    lvlInfo,
    lvlTalkative,
    lvlChatty,
    lvlDebug,
    lvlVomit
} Verbosity;
 
template<>
struct json::is_integral_enum<Verbosity> : std::true_type {};
 
Verbosity verbosityFromIntClamped(int val);
 
struct LinesOfCode {
    std::optional<std::string> prevLineOfCode;
    std::optional<std::string> errLineOfCode;
    std::optional<std::string> nextLineOfCode;
};
 
struct Pos;
 
void printCodeLines(std::ostream & out,
    const std::string & prefix,
    const Pos & errPos,
    const LinesOfCode & loc);
 
enum struct TracePrint {
    Default,
    Always,
};
 
enum struct TraceSize {
};
 
struct Trace {
    std::shared_ptr<Pos> pos;
    HintFmt hint;
    TracePrint print = TracePrint::Default;
};
 
inline bool operator<(const Trace& lhs, const Trace& rhs);
inline bool operator> (const Trace& lhs, const Trace& rhs);
inline bool operator<=(const Trace& lhs, const Trace& rhs);
inline bool operator>=(const Trace& lhs, const Trace& rhs);
 
struct ErrorInfo {
    Verbosity level = Verbosity::lvlError;
    HintFmt msg;
    std::shared_ptr<Pos> pos;
    std::list<Trace> traces = {};
 
    unsigned int status = 1;
 
    Suggestions suggestions = {};
 
    static std::optional<std::string> programName;
};
 
std::ostream & showErrorInfo(std::ostream & out, const ErrorInfo & einfo, bool showTrace);
 
class BaseError : public std::exception
{
protected:
    mutable ErrorInfo err;
 
    mutable std::optional<std::string> what_;
    const std::string & calcWhat() const;
 
public:
    BaseError(const BaseError &) = default;
 
    BaseError & operator=(BaseError const & rhs) = default;
 
    template<typename... Args>
    BaseError(unsigned int status, const Args & ... args)
        : err { .level = lvlError, .msg = HintFmt(args...), .status = status }
    { }
 
    template<typename... Args>
    explicit BaseError(const std::string & fs, const Args & ... args)
        : err { .level = lvlError, .msg = HintFmt(fs, args...) }
    { }
 
    template<typename... Args>
    BaseError(const Suggestions & sug, const Args & ... args)
        : err { .level = lvlError, .msg = HintFmt(args...), .suggestions = sug }
    { }
 
    BaseError(HintFmt hint)
        : err { .level = lvlError, .msg = hint }
    { }
 
    BaseError(ErrorInfo && e)
        : err(std::move(e))
    { }
 
    BaseError(const ErrorInfo & e)
        : err(e)
    { }
 
    const char * what() const noexcept override { return calcWhat().c_str(); }
    const std::string & msg() const { return calcWhat(); }
    const ErrorInfo & info() const { calcWhat(); return err; }
 
    void withExitStatus(unsigned int status)
    {
        err.status = status;
    }
 
    void atPos(std::shared_ptr<Pos> pos) {
        err.pos = pos;
    }
 
    void pushTrace(Trace trace)
    {
        err.traces.push_front(trace);
    }
 
    template<typename... Args>
    void addTrace(std::shared_ptr<Pos> && e, std::string_view fs, const Args & ... args)
    {
        addTrace(std::move(e), HintFmt(std::string(fs), args...));
    }
 
    void addTrace(std::shared_ptr<Pos> && e, HintFmt hint, TracePrint print = TracePrint::Default);
 
    bool hasTrace() const { return !err.traces.empty(); }
 
    const ErrorInfo & info() { return err; };
};
 
#define MakeError(newClass, superClass) \
    /* NOLINTNEXTLINE(bugprone-macro-parentheses) */    \
    class newClass : public superClass                  \
    {                                                   \
    public:                                             \
        using superClass::superClass;                   \
    }
 
MakeError(Error, BaseError);
MakeError(UsageError, Error);
MakeError(UnimplementedError, Error);
 
class SysError : public Error
{
public:
    int errNo;
 
    template<typename... Args>
    SysError(int errNo_, const Args & ... args)
        : Error("")
    {
        errNo = errNo_;
        auto hf = HintFmt(args...);
        err.msg = HintFmt("%1%: %2%", Uncolored(hf.str()), strerror(errNo));
    }
 
    template<typename... Args>
    SysError(std::error_code ec, const Args & ... args)
        : Error("")
    {
        errNo = ec.value();
        auto hf = HintFmt(args...);
        err.msg = HintFmt("%1%: %2%", Uncolored(hf.str()), ec.message());
    }
 
    template<typename... Args>
    SysError(const Args & ... args)
        : SysError(errno, args ...)
    {
    }
};
 
void ignoreExceptionInDestructor(Verbosity lvl = lvlError);
 
void ignoreExceptionExceptInterrupt(Verbosity lvl = lvlError);
 
}