Diagnostic Reference

Floating-point equality is imprecise. Use `~=` (adaptive tolerance), `!~=`, or `math.approx_eq_abs/_rel(...)`. For exact comparisons use the `decimal` type.

A `let`-bound variable or parameter is never read. Prefix the name with `_` to silence the lint intentionally.

A top-level function is never called and is not marked `pub`, `@test`, `@bench`, `@export`, an HTTP route, or `main`.

An imported name is never referenced in the file.

A `let` re-binds a name from an outer scope. Shadowing is sometimes intentional; rename one binding to silence the warning.

Code after `return`, `break`, or `continue` is unreachable.

Functions/variables use `snake_case`; structs/enums/traits/effects use `PascalCase`.

A function or type annotated `@must_use` returned a value that the caller discarded. Bind it (`let _ = ...`) or consume it.

A function annotated `@deprecated` was called. The annotation's message explains the replacement.

A `loop`/`while true` block has no reachable `break`/`return`.

A `Some(...)` / `None` / `?.` / `??` use that looks like a typo or misuse of the optional API.

A `match` over an enum does not cover every variant and has no wildcard `_` arm.

A pattern can never match because an earlier arm already covers it.

Configured via the project's lint config. Default is permissive; tighten in CI if you want hard limits.

Deep nesting hurts readability. Extract helpers or use early-return guard clauses.

Long parameter lists are a code-smell. Consider grouping related parameters into a struct.

Break the function into smaller helpers.

Only `@repr(C)`, `@repr(packed)`, `@repr(transparent)`, and `@repr(zolo)` are recognized.

`transparent` only applies to single-field newtype-style structs.

`@layout` only takes effect alongside an explicit `@repr`.

Alignment must be a positive power of two.

Hardware alignment rules require power-of-two values (1, 2, 4, 8, ...).

The requested alignment exceeds the maximum the target platform supports.

Size cannot be zero or negative.

The lexer reached end-of-file (or end-of-line in some contexts) before finding the closing quote of a string literal.

The parser expected a specific token (e.g. `}`, `)`, identifier, type) but found something else. Usually a missing brace, paren, or punctuation.

A token appeared where the grammar does not allow it — typically a stray symbol, a misspelled keyword, or a missing separator on the previous line.

A parse-level error that did not match a more specific classifier. Read the diagnostic message for the precise cause.

Equivalent to `TE001`. Emitted by the legacy message-pattern classifier when the new typeck did not attach a code.

Legacy alias for `TE100`.

Legacy alias for `TE101`.

Legacy alias for `TE004`. The variable was declared with `let`; use `let mut` to allow reassignment.

Legacy alias for `TE102`.

A struct literal omits one or more required fields.

Legacy alias for `TE110`.

The value being returned does not match the function's declared return type.

A name (function, variable, field, variant) was declared twice in the same scope.

A type annotation refers to a type that the compiler cannot find.

The value assigned to a `let` binding does not satisfy the declared type annotation.

The value assigned to a `const` binding does not satisfy the declared type annotation.

`const` requires a constant-foldable expression. Use `let` for runtime values.

`let` bindings are immutable by default. Use `let mut x = ...` to allow reassignment, or use a fresh `let` shadow.

Operators like `+=`, `-=`, `*=` require both sides to be numeric (or strings for `+=`).

The function declared a tuple return but the actual `return` statement provides fewer values.

The function returns more values than its declared single-value return type can hold.

An array literal mixes incompatible element types; arrays are homogeneous.

Binary arithmetic requires both operands to be numeric and (in strict mode) the same numeric type.

The name is not declared in any enclosing scope. The compiler attaches a "did you mean?" suggestion when a similar name exists.

The callee in a function-call expression is not a callable type.

The struct does not declare this field. "Did you mean?" suggestions are attached for near-matches.

A type annotation or enum-variant field references a type the compiler cannot resolve.

The receiver type does not have a method with this name. Check spelling, imports, and trait visibility.

The number of arguments passed does not match the function's parameter count.

An argument's type does not match the corresponding parameter's declared type.

Strict typing requires every `let`/`const` to have an explicit type annotation.

Strict typing requires every function parameter to have an explicit type.

The number of type arguments supplied does not match the generic's declared parameter count.

A trait bound, `impl` block, or `where` clause references a trait the compiler cannot find.

A collection method (`each`, `filter`, `len`, …) was called on a `Result` or `Option` wrapper directly. Unwrap it first with `?>`, `?`, or `.unwrap()`.

`?.` is null-safe chaining, not fallible unwrapping. A `Result` or `Option` is never `nil`, so the chain runs over the wrapper itself. Use `expr ?> .m(...)`, `let v = expr?`, or `expr!.m(...)` instead.

A function performs an effect (`!io`, `!net`, `!fs`, ...) it did not declare in its signature.

An effect was performed but no enclosing `handle` block handles it.

A `handle` block tries to handle an operation the effect did not declare.

A `handle` block is missing the implementation for one of the effect's declared operations.

The handler references an operation name that does not exist on the effect.

A function signature or handler references an effect the compiler cannot find.

A `perform` call or handler operation does not match the effect's declared signature.

A runtime invariant the compiler emitted code to verify (e.g. bounds, divide-by-zero in const eval) was violated.