const_assert

Invariants over literals, const bindings, and usage inside functions; commented-out diagnostics at the end.

// Feature: `const_assert` — compile-time assertions
// Syntax: `const_assert <expr> [, "message"]`
// When to use: validate compile-time invariants over `const`s and other
// comptime-constant expressions. If the expression evaluates to `false`,
// the build fails with `E_AssertFailed`. Successful asserts produce no
// runtime code — zero cost.
//
// See `specs/const-assert.md` for the full specification.

// Simple assertion over a literal.
const_assert 1 + 1 == 2
const_assert true

// Assertion with an optional human-readable message.
const_assert 10 > 5, "ten must be greater than five"

// Assertions can reference `const` bindings — the comptime engine
// looks them up automatically.
const MAX_BUFFER = 4096
const MIN_BUFFER = 64

const_assert MAX_BUFFER > MIN_BUFFER
const_assert MAX_BUFFER >= 256, "buffer too small for protocol header"
const_assert MAX_BUFFER % 2 == 0, "buffer size must be even"

// `const_assert` is valid inside functions too. Useful when generic
// or template-like code needs to enforce an invariant per call site.
fn validate() {
  const_assert MAX_BUFFER < 1000000
  print("validate ran (asserts already passed at compile time)")
}

validate()
print("PORT validated: max_buffer={MAX_BUFFER}, min={MIN_BUFFER}")
// expected:
// validate ran (asserts already passed at compile time)
// PORT validated: max_buffer=4096, min=64

// Diagnostics (uncomment to see):
//
// 1. `E_AssertFailed` — the expression evaluated to `false`.
//
//    const_assert false, "this must fail"
//    // error[E_AssertFailed]: static assertion failed: this must fail
//
// 2. `E_AssertNotBool` — the expression is not a bool.
//
//    const_assert 42
//    // error[E_AssertNotBool]: `const_assert` expects `bool`, got `Int`
//
// 3. `E_AssertNotConst` — the expression depends on runtime state.
//
//    let runtime_val = some_fn()
//    const_assert runtime_val == 3
//    // error[E_AssertNotConst]: expression in `const_assert` is not
//    //                          comptime-constant

// Difference vs. `assert()` (runtime):
//   const_assert  — evaluated at BUILD time, blocks compilation if false.
//   assert(cond)  — evaluated at RUN time, raises a panic if false.
//
// Use `const_assert` for invariants over `const`s, types, and buffer
// sizes. Use `assert()` for runtime preconditions that depend on input.