A local that is declared but never read.

A module field — a function, global, memory, table, tag, type, or a passive data/element segment — that nothing reachable references. Liveness is reachability from the roots (the exported and start functions, and every reference from a module-level context: an initializer, a segment), so a dead cycle of mutually recursive functions or types is reported, as is anything only dead code references.

An imported function, global, memory, table, or tag that nothing reachable references — the same analysis as Unused_field.

A block label that is declared but never branched to.

A global declared mutable but never assigned, so it could be declared immutable (Wax const, Wasm without mut). Only a module-defined, non-exported global is flagged: an import's mutability is fixed by the linking contract, and an exported mutable global can be assigned by the host.

A shift by a constant count at least as large as the operand's bit width; Wasm masks the count modulo the width, so the shift is almost certainly not what was meant.

An operation that always traps on a constant operand: an integer division or remainder by zero, or a trapping float-to-integer conversion of an out-of-range constant.

A comparison whose result is constant regardless of its variable operand: an unsigned comparison against zero, or a comparison of two identical operands.

A branch, loop, or select condition that is a constant, so it always (or never) takes the same path.

The result of a side-effect-free expression is computed and then discarded (e.g. _ = x + 1).

A statement that can never be reached because it follows an unconditional branch, return, or unreachable.

A reference cast or test whose operand can never have the target type (the two are unrelated in the type hierarchy), so the cast always traps and the test is always false.

A trapping or effectful operation (an integer division, a field or element access, a !, a descriptor cast, a call, an assignment, …) appears in a branch of a ?:. Since ?: compiles to a select, which evaluates both branches, that operation runs even when the condition selects the other branch.

Two operators whose relative precedence is easy to misremember are mixed without parentheses: a shift (<</>>) with an arithmetic operator (+, -, *, …), or a comparison with a bitwise operator (&, |, ^). The code is correct, but a reader (especially one used to C's different table) may misread the grouping.

An operation with no effect on its result: an arithmetic identity (x + 0, x * 1, x << 0, …), an absorbing operand (x * 0, x & 0), an operation on two identical operands (x - x, x ^ x, x & x), a self-assignment (x = x), or a cast to a type the operand already has.

Path-sensitive validation gave up after too many conditional configurations.

Converting from Wasm, a source name collided with another and was renamed to a fresh one.

Converting from Wasm, a source name is a Wax reserved word and was renamed to a fresh one.

Converting from Wasm, an unnamed but referenced parameter was given a generated name (it cannot be rendered anonymously).

A plain assignment could use the compound form: x = x + e reads back as x += e. Carries a machine-applicable rewrite (Suggestion).

A struct field initialised from a like-named local/global could use the punning shorthand: {x: x} reads back as {x} (Suggestion).

A let type annotation the inferred type already makes redundant could be dropped: let x: t = e reads back as let x = e (Suggestion).

A string (an export/import name, a string literal, or a data segment) contains a bidirectional control character that can make the source read differently than it runs (a "Trojan Source" character).

Suppress the warning entirely.

Report it as a warning (the default).

Promote it to an error (fails the run).