forked from lix-project/lix
eldritch horrors
08252967a8
While preparing PRs like #9753, I've had to change error messages in
dozens of code paths. It would be nice if instead of
EvalError("expected 'boolean' but found '%1%'", showType(v))
we could write
TypeError(v, "boolean")
or similar. Then, changing the error message could be a mechanical
refactor with the compiler pointing out places the constructor needs to
be changed, rather than the error-prone process of grepping through the
codebase. Structured errors would also help prevent the "same" error
from having multiple slightly different messages, and could be a first
step towards error codes / an error index.
This PR reworks the exception infrastructure in `libexpr` to
support exception types with different constructor signatures than
`BaseError`. Actually refactoring the exceptions to use structured data
will come in a future PR (this one is big enough already, as it has to
touch every exception in `libexpr`).
The core design is in `eval-error.hh`. Generally, errors like this:
state.error("'%s' is not a string", getAttrPathStr())
.debugThrow<TypeError>()
are transformed like this:
state.error<TypeError>("'%s' is not a string", getAttrPathStr())
.debugThrow()
The type annotation has moved from `ErrorBuilder::debugThrow` to
`EvalState::error`.
(cherry picked from commit c6a89c1a1659b31694c0fbcd21d78a6dd521c732)
Change-Id: Iced91ba4e00ca9e801518071fb43798936cbd05a
143 lines
3.5 KiB
C++
143 lines
3.5 KiB
C++
#pragma once
|
|
///@file
|
|
|
|
#include "print.hh"
|
|
#include "eval.hh"
|
|
#include "eval-error.hh"
|
|
|
|
namespace nix {
|
|
|
|
/**
|
|
* Note: Various places expect the allocated memory to be zeroed.
|
|
*/
|
|
[[gnu::always_inline]]
|
|
inline void * allocBytes(size_t n)
|
|
{
|
|
void * p;
|
|
#if HAVE_BOEHMGC
|
|
p = GC_MALLOC(n);
|
|
#else
|
|
p = calloc(n, 1);
|
|
#endif
|
|
if (!p) throw std::bad_alloc();
|
|
return p;
|
|
}
|
|
|
|
|
|
[[gnu::always_inline]]
|
|
Value * EvalState::allocValue()
|
|
{
|
|
#if HAVE_BOEHMGC
|
|
/* We use the boehm batch allocator to speed up allocations of Values (of which there are many).
|
|
GC_malloc_many returns a linked list of objects of the given size, where the first word
|
|
of each object is also the pointer to the next object in the list. This also means that we
|
|
have to explicitly clear the first word of every object we take. */
|
|
if (!*valueAllocCache) {
|
|
*valueAllocCache = GC_malloc_many(sizeof(Value));
|
|
if (!*valueAllocCache) throw std::bad_alloc();
|
|
}
|
|
|
|
/* GC_NEXT is a convenience macro for accessing the first word of an object.
|
|
Take the first list item, advance the list to the next item, and clear the next pointer. */
|
|
void * p = *valueAllocCache;
|
|
*valueAllocCache = GC_NEXT(p);
|
|
GC_NEXT(p) = nullptr;
|
|
#else
|
|
void * p = allocBytes(sizeof(Value));
|
|
#endif
|
|
|
|
nrValues++;
|
|
return (Value *) p;
|
|
}
|
|
|
|
|
|
[[gnu::always_inline]]
|
|
Env & EvalState::allocEnv(size_t size)
|
|
{
|
|
nrEnvs++;
|
|
nrValuesInEnvs += size;
|
|
|
|
Env * env;
|
|
|
|
#if HAVE_BOEHMGC
|
|
if (size == 1) {
|
|
/* see allocValue for explanations. */
|
|
if (!*env1AllocCache) {
|
|
*env1AllocCache = GC_malloc_many(sizeof(Env) + sizeof(Value *));
|
|
if (!*env1AllocCache) throw std::bad_alloc();
|
|
}
|
|
|
|
void * p = *env1AllocCache;
|
|
*env1AllocCache = GC_NEXT(p);
|
|
GC_NEXT(p) = nullptr;
|
|
env = (Env *) p;
|
|
} else
|
|
#endif
|
|
env = (Env *) allocBytes(sizeof(Env) + size * sizeof(Value *));
|
|
|
|
/* We assume that env->values has been cleared by the allocator; maybeThunk() and lookupVar fromWith expect this. */
|
|
|
|
return *env;
|
|
}
|
|
|
|
|
|
[[gnu::always_inline]]
|
|
void EvalState::forceValue(Value & v, const PosIdx pos)
|
|
{
|
|
if (v.isThunk()) {
|
|
Env * env = v.thunk.env;
|
|
Expr * expr = v.thunk.expr;
|
|
try {
|
|
v.mkBlackhole();
|
|
//checkInterrupt();
|
|
expr->eval(*this, *env, v);
|
|
} catch (...) {
|
|
v.mkThunk(env, expr);
|
|
tryFixupBlackHolePos(v, pos);
|
|
throw;
|
|
}
|
|
}
|
|
else if (v.isApp())
|
|
callFunction(*v.app.left, *v.app.right, v, pos);
|
|
}
|
|
|
|
|
|
[[gnu::always_inline]]
|
|
inline void EvalState::forceAttrs(Value & v, const PosIdx pos, std::string_view errorCtx)
|
|
{
|
|
forceAttrs(v, [&]() { return pos; }, errorCtx);
|
|
}
|
|
|
|
|
|
template <typename Callable>
|
|
[[gnu::always_inline]]
|
|
inline void EvalState::forceAttrs(Value & v, Callable getPos, std::string_view errorCtx)
|
|
{
|
|
PosIdx pos = getPos();
|
|
forceValue(v, pos);
|
|
if (v.type() != nAttrs) {
|
|
error<TypeError>(
|
|
"expected a set but found %1%: %2%",
|
|
showType(v),
|
|
ValuePrinter(*this, v, errorPrintOptions)
|
|
).withTrace(pos, errorCtx).debugThrow();
|
|
}
|
|
}
|
|
|
|
|
|
[[gnu::always_inline]]
|
|
inline void EvalState::forceList(Value & v, const PosIdx pos, std::string_view errorCtx)
|
|
{
|
|
forceValue(v, pos);
|
|
if (!v.isList()) {
|
|
error<TypeError>(
|
|
"expected a list but found %1%: %2%",
|
|
showType(v),
|
|
ValuePrinter(*this, v, errorPrintOptions)
|
|
).withTrace(pos, errorCtx).debugThrow();
|
|
}
|
|
}
|
|
|
|
|
|
}
|