Handling constexpr evaluations in a compiler involves evaluating expressions at compile time whenever possible, and reporting errors if constexpr functions or variables are used in a way that requires runtime evaluation.

Here's a basic overview of how a compiler might handle constexpr:

1. Parsing and Checking: When the compiler parses the source code, it checks for the constexpr keyword. If a function is marked constexpr, the compiler checks to ensure that it meets the requirements for constexpr functions (for example, it must have a non-void return type, it can't be a coroutine, it can't have certain types of statements like static_assert, etc.). Similarly, if a variable is marked constexpr, the compiler ensures that its initializer is a constant expression.

2. Constant Expression Evaluation: During the semantic analysis phase, the compiler will try to evaluate constant expressions. For constexpr functions, this means the function is evaluated at compile time whenever it is called with arguments that are constant expressions. For constexpr variables, this means the initializer is evaluated at compile time. This is done by the compiler's "constant evaluator", a component that's capable of evaluating expressions without running the full program.

3. Instantiation: If a constexpr function is called with non-constant arguments, it is instantiated as a regular function and evaluated at runtime. This is because constexpr functions in C++ are required to be valid for both compile-time and runtime contexts.

4. Error Reporting: If a constexpr variable is used in a context that requires a constant expression, but its initializer can't be evaluated as a constant expression, the compiler reports an error. Similarly, if a constexpr function is used in a constant expression context but can't be evaluated at compile time with the given arguments, the compiler reports an error.

In terms of determining whether an expression is evaluable at compile time, the rules are defined by the language specification. For C++, some basic rules are:

• Literal values (like 42 or 3.14) are compile-time evaluable.
• proj/uvlang/exprs involving only literal values and constexpr functions or operators are compile-time evaluable.
• Variables declared constexpr and initialized with a compile-time evaluable expression are themselves compile-time evaluable.
• Any more complex expressions, or expressions involving non-constexpr variables or functions, generally aren't compile-time evaluable.

The actual rules are quite complex, particularly because C++ allows for things like template metaprogramming, which can result in complex compile-time computations. Implementing this in a compiler requires a careful reading of the C++ standard and a deep understanding of the language's semantics.