redscript-mc 3.0.1 → 3.0.2

package/dist/src/lint/index.js

@@ -6,11 +6,16 @@
  * Run after HIR lowering, before MIR.
  *
  * Rules:
- *   unused-variable   — let x = 5 but x never read
- *   unused-import     — import math::sin but sin never called
- *   magic-number      — literal number > 1 used directly (0 and 1 ignored)
- *   dead-branch       — if (const == const) always-true/false condition
- *   function-too-long — function body exceeds 50 lines
+ *   unused-variable        — let x = 5 but x never read
+ *   unused-import          — import math::sin but sin never called
+ *   magic-number           — literal number > 1 used directly (0 and 1 ignored)
+ *   dead-branch            — if (const == const) always-true/false condition
+ *   function-too-long      — function body exceeds 50 lines
+ *   no-dead-assignment     — variable assigned but never read after the assignment
+ *   prefer-match-exhaustive — Option match missing Some or None arm
+ *   no-empty-catch         — empty else branch in if_let_some (silent failure)
+ *   naming-convention      — variables must be camelCase; types must be PascalCase
+ *   no-magic-numbers       — any literal number other than 0 or 1 used in an expression
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -65,6 +70,7 @@ function lintSource(source, imports, hir, options = {}) {
     const warnings = [];
     const file = options.filePath;
     const maxLines = options.maxFunctionLines ?? 50;
+    const allowedNumbers = options.allowedNumbers ?? [0, 1];
     // Rule: unused-import
     warnings.push(...checkUnusedImports(imports, hir, file));
     for (const fn of hir.functions) {
@@ -80,7 +86,19 @@ function lintSource(source, imports, hir, options = {}) {
         const fnWarning = checkFunctionLength(fn, maxLines, file);
         if (fnWarning)
             warnings.push(fnWarning);
+        // Rule: no-dead-assignment
+        warnings.push(...checkNoDeadAssignment(fn, file));
+        // Rule: prefer-match-exhaustive
+        warnings.push(...checkPreferMatchExhaustive(fn, file));
+        // Rule: no-empty-catch
+        warnings.push(...checkNoEmptyCatch(fn, file));
+        // Rule: naming-convention
+        warnings.push(...checkNamingConvention(fn, file));
+        // Rule: no-magic-numbers
+        warnings.push(...checkNoMagicNumbers(fn, allowedNumbers, file));
     }
+    // Rule: naming-convention — type names in structs/enums
+    warnings.push(...checkNamingConventionModule(hir, file));
     return warnings;
 }
 /**
@@ -927,4 +945,711 @@ function countStmts(block) {
     }
     return count;
 }
+// ---------------------------------------------------------------------------
+// Rule: no-dead-assignment
+// ---------------------------------------------------------------------------
+//
+// Detects variables that are assigned (via `assign` expr) but whose value is
+// never subsequently read. This is stricter than unused-variable: the variable
+// IS read at some point, but a particular write is "dead" because it is
+// overwritten before being read.
+//
+// Implementation: single-pass, scope-insensitive. We track every assignment
+// target and warn if the same name is assigned twice with no intervening read.
+function checkNoDeadAssignment(fn, file) {
+    const warnings = [];
+    // Map from name → span of the last unread assignment
+    const pendingWrite = new Map();
+    noDeadAssignBlock(fn.body, pendingWrite, warnings, file);
+    return warnings;
+}
+function noDeadAssignBlock(block, pending, out, file) {
+    for (const stmt of block) {
+        noDeadAssignStmt(stmt, pending, out, file);
+    }
+}
+function noDeadAssignStmt(stmt, pending, out, file) {
+    switch (stmt.kind) {
+        case 'let':
+            // Initial let binding — register as pending write
+            noDeadAssignExprReads(stmt.init, pending, out, file);
+            pending.set(stmt.name, { span: stmt.span });
+            break;
+        case 'let_destruct':
+            noDeadAssignExprReads(stmt.init, pending, out, file);
+            for (const name of stmt.names)
+                pending.set(name, { span: stmt.span });
+            break;
+        case 'const_decl':
+            noDeadAssignExprReads(stmt.value, pending, out, file);
+            break;
+        case 'expr':
+            noDeadAssignExprReads(stmt.expr, pending, out, file);
+            break;
+        case 'return':
+            if (stmt.value)
+                noDeadAssignExprReads(stmt.value, pending, out, file);
+            break;
+        case 'if':
+            noDeadAssignExprReads(stmt.cond, pending, out, file);
+            noDeadAssignBlock(stmt.then, pending, out, file);
+            if (stmt.else_)
+                noDeadAssignBlock(stmt.else_, pending, out, file);
+            break;
+        case 'while':
+            noDeadAssignExprReads(stmt.cond, pending, out, file);
+            noDeadAssignBlock(stmt.body, pending, out, file);
+            if (stmt.step)
+                noDeadAssignBlock(stmt.step, pending, out, file);
+            break;
+        case 'foreach':
+            noDeadAssignExprReads(stmt.iterable, pending, out, file);
+            noDeadAssignBlock(stmt.body, pending, out, file);
+            break;
+        case 'match':
+            noDeadAssignExprReads(stmt.expr, pending, out, file);
+            for (const arm of stmt.arms)
+                noDeadAssignBlock(arm.body, pending, out, file);
+            break;
+        case 'execute':
+            noDeadAssignBlock(stmt.body, pending, out, file);
+            break;
+        case 'if_let_some':
+            noDeadAssignExprReads(stmt.init, pending, out, file);
+            noDeadAssignBlock(stmt.then, pending, out, file);
+            if (stmt.else_)
+                noDeadAssignBlock(stmt.else_, pending, out, file);
+            break;
+        case 'while_let_some':
+            noDeadAssignExprReads(stmt.init, pending, out, file);
+            noDeadAssignBlock(stmt.body, pending, out, file);
+            break;
+        case 'labeled_loop':
+            noDeadAssignStmt(stmt.body, pending, out, file);
+            break;
+    }
+}
+/** Processes an expression: reads clear pending writes; assign exprs register new pending writes. */
+function noDeadAssignExprReads(expr, pending, out, file) {
+    if (!expr)
+        return;
+    switch (expr.kind) {
+        case 'ident':
+            // Reading a variable clears its pending write
+            pending.delete(expr.name);
+            break;
+        case 'assign': {
+            // RHS is read first
+            noDeadAssignExprReads(expr.value, pending, out, file);
+            // Then the target is written — if there's already a pending unread write, warn
+            if (pending.has(expr.target)) {
+                const prev = pending.get(expr.target);
+                const warn = {
+                    rule: 'no-dead-assignment',
+                    message: `Assignment to "${expr.target}" is never read before being overwritten`,
+                    file,
+                };
+                if (prev.span) {
+                    warn.line = prev.span.line;
+                    warn.col = prev.span.col;
+                }
+                out.push(warn);
+            }
+            pending.set(expr.target, { span: expr.span });
+            break;
+        }
+        case 'binary':
+            noDeadAssignExprReads(expr.left, pending, out, file);
+            noDeadAssignExprReads(expr.right, pending, out, file);
+            break;
+        case 'unary':
+            noDeadAssignExprReads(expr.operand, pending, out, file);
+            break;
+        case 'call':
+            for (const arg of expr.args)
+                noDeadAssignExprReads(arg, pending, out, file);
+            break;
+        case 'invoke':
+            noDeadAssignExprReads(expr.callee, pending, out, file);
+            for (const arg of expr.args)
+                noDeadAssignExprReads(arg, pending, out, file);
+            break;
+        case 'static_call':
+            for (const arg of expr.args)
+                noDeadAssignExprReads(arg, pending, out, file);
+            break;
+        case 'member':
+            noDeadAssignExprReads(expr.obj, pending, out, file);
+            break;
+        case 'member_assign':
+            noDeadAssignExprReads(expr.obj, pending, out, file);
+            noDeadAssignExprReads(expr.value, pending, out, file);
+            break;
+        case 'index':
+            noDeadAssignExprReads(expr.obj, pending, out, file);
+            noDeadAssignExprReads(expr.index, pending, out, file);
+            break;
+        case 'index_assign':
+            noDeadAssignExprReads(expr.obj, pending, out, file);
+            noDeadAssignExprReads(expr.index, pending, out, file);
+            noDeadAssignExprReads(expr.value, pending, out, file);
+            break;
+        case 'some_lit':
+            noDeadAssignExprReads(expr.value, pending, out, file);
+            break;
+        case 'unwrap_or':
+            noDeadAssignExprReads(expr.opt, pending, out, file);
+            noDeadAssignExprReads(expr.default_, pending, out, file);
+            break;
+        case 'type_cast':
+            noDeadAssignExprReads(expr.expr, pending, out, file);
+            break;
+        case 'array_lit':
+        case 'tuple_lit':
+            for (const e of expr.elements)
+                noDeadAssignExprReads(e, pending, out, file);
+            break;
+        case 'struct_lit':
+            for (const f of expr.fields)
+                noDeadAssignExprReads(f.value, pending, out, file);
+            break;
+        case 'str_interp':
+            for (const p of expr.parts) {
+                if (typeof p !== 'string')
+                    noDeadAssignExprReads(p, pending, out, file);
+            }
+            break;
+        case 'f_string':
+            for (const p of expr.parts) {
+                if (p.kind === 'expr')
+                    noDeadAssignExprReads(p.expr, pending, out, file);
+            }
+            break;
+        case 'lambda':
+            if (Array.isArray(expr.body)) {
+                noDeadAssignBlock(expr.body, pending, out, file);
+            }
+            else {
+                noDeadAssignExprReads(expr.body, pending, out, file);
+            }
+            break;
+        case 'enum_construct':
+            for (const f of expr.args)
+                noDeadAssignExprReads(f.value, pending, out, file);
+            break;
+        default:
+            break;
+    }
+}
+// ---------------------------------------------------------------------------
+// Rule: prefer-match-exhaustive
+// ---------------------------------------------------------------------------
+//
+// When a match statement uses Option patterns (PatSome / PatNone), it should
+// cover both arms. Missing PatNone means the None case falls through silently;
+// missing PatSome means Some values are unhandled.
+function checkPreferMatchExhaustive(fn, file) {
+    const warnings = [];
+    checkPreferMatchExhaustiveBlock(fn.body, warnings, file);
+    return warnings;
+}
+function checkPreferMatchExhaustiveBlock(block, out, file) {
+    for (const stmt of block) {
+        checkPreferMatchExhaustiveStmt(stmt, out, file);
+    }
+}
+function checkPreferMatchExhaustiveStmt(stmt, out, file) {
+    switch (stmt.kind) {
+        case 'match': {
+            const patKinds = new Set(stmt.arms.map(a => a.pattern.kind));
+            const hasOptionPat = patKinds.has('PatSome') || patKinds.has('PatNone');
+            const hasWild = patKinds.has('PatWild');
+            if (hasOptionPat && !hasWild) {
+                const hasSome = patKinds.has('PatSome');
+                const hasNone = patKinds.has('PatNone');
+                if (!hasSome) {
+                    const warn = {
+                        rule: 'prefer-match-exhaustive',
+                        message: `match on Option is missing a Some(_) arm`,
+                        file,
+                    };
+                    if (stmt.span) {
+                        warn.line = stmt.span.line;
+                        warn.col = stmt.span.col;
+                    }
+                    out.push(warn);
+                }
+                if (!hasNone) {
+                    const warn = {
+                        rule: 'prefer-match-exhaustive',
+                        message: `match on Option is missing a None arm`,
+                        file,
+                    };
+                    if (stmt.span) {
+                        warn.line = stmt.span.line;
+                        warn.col = stmt.span.col;
+                    }
+                    out.push(warn);
+                }
+            }
+            // Recurse into arm bodies
+            for (const arm of stmt.arms)
+                checkPreferMatchExhaustiveBlock(arm.body, out, file);
+            break;
+        }
+        case 'if':
+            checkPreferMatchExhaustiveBlock(stmt.then, out, file);
+            if (stmt.else_)
+                checkPreferMatchExhaustiveBlock(stmt.else_, out, file);
+            break;
+        case 'while':
+            checkPreferMatchExhaustiveBlock(stmt.body, out, file);
+            if (stmt.step)
+                checkPreferMatchExhaustiveBlock(stmt.step, out, file);
+            break;
+        case 'foreach':
+            checkPreferMatchExhaustiveBlock(stmt.body, out, file);
+            break;
+        case 'execute':
+            checkPreferMatchExhaustiveBlock(stmt.body, out, file);
+            break;
+        case 'if_let_some':
+            checkPreferMatchExhaustiveBlock(stmt.then, out, file);
+            if (stmt.else_)
+                checkPreferMatchExhaustiveBlock(stmt.else_, out, file);
+            break;
+        case 'while_let_some':
+            checkPreferMatchExhaustiveBlock(stmt.body, out, file);
+            break;
+        case 'labeled_loop':
+            checkPreferMatchExhaustiveStmt(stmt.body, out, file);
+            break;
+    }
+}
+// ---------------------------------------------------------------------------
+// Rule: no-empty-catch
+// ---------------------------------------------------------------------------
+//
+// RedScript has no try/catch. The equivalent pattern is `if_let_some` with an
+// empty else_ block (silently ignoring the None case) or a match arm whose
+// body is empty. Both patterns silently swallow a failure — warn about them.
+function checkNoEmptyCatch(fn, file) {
+    const warnings = [];
+    checkNoEmptyCatchBlock(fn.body, warnings, file);
+    return warnings;
+}
+function checkNoEmptyCatchBlock(block, out, file) {
+    for (const stmt of block) {
+        checkNoEmptyCatchStmt(stmt, out, file);
+    }
+}
+function checkNoEmptyCatchStmt(stmt, out, file) {
+    switch (stmt.kind) {
+        case 'if_let_some':
+            if (stmt.else_ && stmt.else_.length === 0) {
+                const warn = {
+                    rule: 'no-empty-catch',
+                    message: `Empty else block in if let Some — None case is silently ignored`,
+                    file,
+                };
+                if (stmt.span) {
+                    warn.line = stmt.span.line;
+                    warn.col = stmt.span.col;
+                }
+                out.push(warn);
+            }
+            checkNoEmptyCatchBlock(stmt.then, out, file);
+            if (stmt.else_)
+                checkNoEmptyCatchBlock(stmt.else_, out, file);
+            break;
+        case 'match':
+            for (const arm of stmt.arms) {
+                if (arm.body.length === 0) {
+                    const warn = {
+                        rule: 'no-empty-catch',
+                        message: `Empty match arm body — consider handling this case explicitly`,
+                        file,
+                    };
+                    if (stmt.span) {
+                        warn.line = stmt.span.line;
+                        warn.col = stmt.span.col;
+                    }
+                    out.push(warn);
+                }
+                checkNoEmptyCatchBlock(arm.body, out, file);
+            }
+            break;
+        case 'if':
+            checkNoEmptyCatchBlock(stmt.then, out, file);
+            if (stmt.else_)
+                checkNoEmptyCatchBlock(stmt.else_, out, file);
+            break;
+        case 'while':
+            checkNoEmptyCatchBlock(stmt.body, out, file);
+            if (stmt.step)
+                checkNoEmptyCatchBlock(stmt.step, out, file);
+            break;
+        case 'foreach':
+            checkNoEmptyCatchBlock(stmt.body, out, file);
+            break;
+        case 'execute':
+            checkNoEmptyCatchBlock(stmt.body, out, file);
+            break;
+        case 'while_let_some':
+            checkNoEmptyCatchBlock(stmt.body, out, file);
+            break;
+        case 'labeled_loop':
+            checkNoEmptyCatchStmt(stmt.body, out, file);
+            break;
+    }
+}
+// ---------------------------------------------------------------------------
+// Rule: naming-convention
+// ---------------------------------------------------------------------------
+//
+// Variables (let bindings, foreach bindings) must use camelCase.
+// Type names (structs, enums) must use PascalCase.
+//
+// camelCase: starts with lowercase letter, no underscores (except leading _)
+// PascalCase: starts with uppercase letter
+function isCamelCase(name) {
+    // Allow leading underscore (private convention), then must start lowercase
+    const stripped = name.startsWith('_') ? name.slice(1) : name;
+    if (stripped.length === 0)
+        return true;
+    // Must start with lowercase, no underscores after first char
+    return /^[a-z][a-zA-Z0-9]*$/.test(stripped);
+}
+function isPascalCase(name) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+}
+function checkNamingConvention(fn, file) {
+    const warnings = [];
+    checkNamingConventionBlock(fn.body, warnings, file);
+    return warnings;
+}
+function checkNamingConventionBlock(block, out, file) {
+    for (const stmt of block) {
+        checkNamingConventionStmt(stmt, out, file);
+    }
+}
+function checkNamingConventionStmt(stmt, out, file) {
+    switch (stmt.kind) {
+        case 'let':
+            if (!isCamelCase(stmt.name)) {
+                const warn = {
+                    rule: 'naming-convention',
+                    message: `Variable "${stmt.name}" should use camelCase`,
+                    file,
+                };
+                if (stmt.span) {
+                    warn.line = stmt.span.line;
+                    warn.col = stmt.span.col;
+                }
+                out.push(warn);
+            }
+            break;
+        case 'let_destruct':
+            for (const name of stmt.names) {
+                if (!isCamelCase(name)) {
+                    const warn = {
+                        rule: 'naming-convention',
+                        message: `Variable "${name}" should use camelCase`,
+                        file,
+                    };
+                    if (stmt.span) {
+                        warn.line = stmt.span.line;
+                        warn.col = stmt.span.col;
+                    }
+                    out.push(warn);
+                }
+            }
+            break;
+        case 'foreach':
+            if (!isCamelCase(stmt.binding)) {
+                const warn = {
+                    rule: 'naming-convention',
+                    message: `Loop variable "${stmt.binding}" should use camelCase`,
+                    file,
+                };
+                if (stmt.span) {
+                    warn.line = stmt.span.line;
+                    warn.col = stmt.span.col;
+                }
+                out.push(warn);
+            }
+            checkNamingConventionBlock(stmt.body, out, file);
+            break;
+        case 'if':
+            checkNamingConventionBlock(stmt.then, out, file);
+            if (stmt.else_)
+                checkNamingConventionBlock(stmt.else_, out, file);
+            break;
+        case 'while':
+            checkNamingConventionBlock(stmt.body, out, file);
+            if (stmt.step)
+                checkNamingConventionBlock(stmt.step, out, file);
+            break;
+        case 'match':
+            for (const arm of stmt.arms)
+                checkNamingConventionBlock(arm.body, out, file);
+            break;
+        case 'execute':
+            checkNamingConventionBlock(stmt.body, out, file);
+            break;
+        case 'if_let_some':
+            if (!isCamelCase(stmt.binding)) {
+                const warn = {
+                    rule: 'naming-convention',
+                    message: `Binding "${stmt.binding}" should use camelCase`,
+                    file,
+                };
+                if (stmt.span) {
+                    warn.line = stmt.span.line;
+                    warn.col = stmt.span.col;
+                }
+                out.push(warn);
+            }
+            checkNamingConventionBlock(stmt.then, out, file);
+            if (stmt.else_)
+                checkNamingConventionBlock(stmt.else_, out, file);
+            break;
+        case 'while_let_some':
+            if (!isCamelCase(stmt.binding)) {
+                const warn = {
+                    rule: 'naming-convention',
+                    message: `Binding "${stmt.binding}" should use camelCase`,
+                    file,
+                };
+                if (stmt.span) {
+                    warn.line = stmt.span.line;
+                    warn.col = stmt.span.col;
+                }
+                out.push(warn);
+            }
+            checkNamingConventionBlock(stmt.body, out, file);
+            break;
+        case 'labeled_loop':
+            checkNamingConventionStmt(stmt.body, out, file);
+            break;
+    }
+}
+/** Check type names (structs and enums) at the module level. */
+function checkNamingConventionModule(hir, file) {
+    const warnings = [];
+    for (const s of hir.structs) {
+        if (!isPascalCase(s.name)) {
+            const warn = {
+                rule: 'naming-convention',
+                message: `Struct "${s.name}" should use PascalCase`,
+                file,
+            };
+            if (s.span) {
+                warn.line = s.span.line;
+                warn.col = s.span.col;
+            }
+            warnings.push(warn);
+        }
+    }
+    for (const e of hir.enums) {
+        if (!isPascalCase(e.name)) {
+            const warn = {
+                rule: 'naming-convention',
+                message: `Enum "${e.name}" should use PascalCase`,
+                file,
+            };
+            if (e.span) {
+                warn.line = e.span.line;
+                warn.col = e.span.col;
+            }
+            warnings.push(warn);
+        }
+    }
+    return warnings;
+}
+// ---------------------------------------------------------------------------
+// Rule: no-magic-numbers
+// ---------------------------------------------------------------------------
+//
+// Flags any numeric literal that is not in the allowedNumbers list (default
+// [0, 1]) when used outside of a const declaration. Unlike the older
+// magic-number rule (threshold > 1), this rule checks against an explicit
+// allow-list, making it configurable for different projects.
+function checkNoMagicNumbers(fn, allowed, file) {
+    const warnings = [];
+    const allowedSet = new Set(allowed);
+    checkNoMagicNumbersBlock(fn.body, warnings, file, allowedSet, /*inConst=*/ false);
+    return warnings;
+}
+function checkNoMagicNumbersBlock(block, out, file, allowed, inConst) {
+    for (const stmt of block) {
+        checkNoMagicNumbersStmt(stmt, out, file, allowed, inConst);
+    }
+}
+function checkNoMagicNumbersStmt(stmt, out, file, allowed, inConst) {
+    switch (stmt.kind) {
+        case 'const_decl':
+            // Numbers in const declarations are the intended fix — skip
+            break;
+        case 'let':
+            checkNoMagicNumbersExpr(stmt.init, out, file, allowed);
+            break;
+        case 'let_destruct':
+            checkNoMagicNumbersExpr(stmt.init, out, file, allowed);
+            break;
+        case 'expr':
+            checkNoMagicNumbersExpr(stmt.expr, out, file, allowed);
+            break;
+        case 'return':
+            if (stmt.value)
+                checkNoMagicNumbersExpr(stmt.value, out, file, allowed);
+            break;
+        case 'if':
+            checkNoMagicNumbersExpr(stmt.cond, out, file, allowed);
+            checkNoMagicNumbersBlock(stmt.then, out, file, allowed, false);
+            if (stmt.else_)
+                checkNoMagicNumbersBlock(stmt.else_, out, file, allowed, false);
+            break;
+        case 'while':
+            checkNoMagicNumbersExpr(stmt.cond, out, file, allowed);
+            checkNoMagicNumbersBlock(stmt.body, out, file, allowed, false);
+            if (stmt.step)
+                checkNoMagicNumbersBlock(stmt.step, out, file, allowed, false);
+            break;
+        case 'foreach':
+            checkNoMagicNumbersExpr(stmt.iterable, out, file, allowed);
+            checkNoMagicNumbersBlock(stmt.body, out, file, allowed, false);
+            break;
+        case 'match':
+            checkNoMagicNumbersExpr(stmt.expr, out, file, allowed);
+            for (const arm of stmt.arms)
+                checkNoMagicNumbersBlock(arm.body, out, file, allowed, false);
+            break;
+        case 'execute':
+            checkNoMagicNumbersBlock(stmt.body, out, file, allowed, false);
+            break;
+        case 'if_let_some':
+            checkNoMagicNumbersExpr(stmt.init, out, file, allowed);
+            checkNoMagicNumbersBlock(stmt.then, out, file, allowed, false);
+            if (stmt.else_)
+                checkNoMagicNumbersBlock(stmt.else_, out, file, allowed, false);
+            break;
+        case 'while_let_some':
+            checkNoMagicNumbersExpr(stmt.init, out, file, allowed);
+            checkNoMagicNumbersBlock(stmt.body, out, file, allowed, false);
+            break;
+        case 'labeled_loop':
+            checkNoMagicNumbersStmt(stmt.body, out, file, allowed, inConst);
+            break;
+    }
+}
+function checkNoMagicNumbersExpr(expr, out, file, allowed) {
+    if (!expr)
+        return;
+    switch (expr.kind) {
+        case 'int_lit':
+        case 'float_lit':
+        case 'byte_lit':
+        case 'short_lit':
+        case 'long_lit':
+        case 'double_lit':
+            if (!allowed.has(expr.value)) {
+                const warn = {
+                    rule: 'no-magic-numbers',
+                    message: `Magic number ${expr.value} — extract to a named const`,
+                    file,
+                };
+                if (expr.span) {
+                    warn.line = expr.span.line;
+                    warn.col = expr.span.col;
+                }
+                out.push(warn);
+            }
+            break;
+        case 'binary':
+            checkNoMagicNumbersExpr(expr.left, out, file, allowed);
+            checkNoMagicNumbersExpr(expr.right, out, file, allowed);
+            break;
+        case 'unary':
+            checkNoMagicNumbersExpr(expr.operand, out, file, allowed);
+            break;
+        case 'call':
+            for (const arg of expr.args)
+                checkNoMagicNumbersExpr(arg, out, file, allowed);
+            break;
+        case 'invoke':
+            checkNoMagicNumbersExpr(expr.callee, out, file, allowed);
+            for (const arg of expr.args)
+                checkNoMagicNumbersExpr(arg, out, file, allowed);
+            break;
+        case 'static_call':
+            for (const arg of expr.args)
+                checkNoMagicNumbersExpr(arg, out, file, allowed);
+            break;
+        case 'member':
+            checkNoMagicNumbersExpr(expr.obj, out, file, allowed);
+            break;
+        case 'member_assign':
+            checkNoMagicNumbersExpr(expr.obj, out, file, allowed);
+            checkNoMagicNumbersExpr(expr.value, out, file, allowed);
+            break;
+        case 'index':
+            checkNoMagicNumbersExpr(expr.obj, out, file, allowed);
+            checkNoMagicNumbersExpr(expr.index, out, file, allowed);
+            break;
+        case 'index_assign':
+            checkNoMagicNumbersExpr(expr.obj, out, file, allowed);
+            checkNoMagicNumbersExpr(expr.index, out, file, allowed);
+            checkNoMagicNumbersExpr(expr.value, out, file, allowed);
+            break;
+        case 'assign':
+            checkNoMagicNumbersExpr(expr.value, out, file, allowed);
+            break;
+        case 'some_lit':
+            checkNoMagicNumbersExpr(expr.value, out, file, allowed);
+            break;
+        case 'unwrap_or':
+            checkNoMagicNumbersExpr(expr.opt, out, file, allowed);
+            checkNoMagicNumbersExpr(expr.default_, out, file, allowed);
+            break;
+        case 'type_cast':
+            checkNoMagicNumbersExpr(expr.expr, out, file, allowed);
+            break;
+        case 'array_lit':
+        case 'tuple_lit':
+            for (const e of expr.elements)
+                checkNoMagicNumbersExpr(e, out, file, allowed);
+            break;
+        case 'struct_lit':
+            for (const f of expr.fields)
+                checkNoMagicNumbersExpr(f.value, out, file, allowed);
+            break;
+        case 'str_interp':
+            for (const p of expr.parts) {
+                if (typeof p !== 'string')
+                    checkNoMagicNumbersExpr(p, out, file, allowed);
+            }
+            break;
+        case 'f_string':
+            for (const p of expr.parts) {
+                if (p.kind === 'expr')
+                    checkNoMagicNumbersExpr(p.expr, out, file, allowed);
+            }
+            break;
+        case 'lambda':
+            if (Array.isArray(expr.body)) {
+                checkNoMagicNumbersBlock(expr.body, out, file, allowed, false);
+            }
+            else {
+                checkNoMagicNumbersExpr(expr.body, out, file, allowed);
+            }
+            break;
+        case 'enum_construct':
+            for (const f of expr.args)
+                checkNoMagicNumbersExpr(f.value, out, file, allowed);
+            break;
+        default:
+            break;
+    }
+}
 //# sourceMappingURL=index.js.map