c-next 0.1.2 → 0.1.4

package/README.md

@@ -661,42 +661,43 @@ Decisions are documented in `/docs/decisions/`:
 
 ### Implemented
 
-| ADR                                                          | Title                   | Description                                                  |
-| ------------------------------------------------------------ | ----------------------- | ------------------------------------------------------------ |
-| [ADR-001](docs/decisions/adr-001-assignment-operator.md)     | Assignment Operator     | `<-` for assignment, `=` for comparison                      |
-| [ADR-003](docs/decisions/adr-003-static-allocation.md)       | Static Allocation       | No dynamic memory after init                                 |
-| [ADR-004](docs/decisions/adr-004-register-bindings.md)       | Register Bindings       | Type-safe hardware access                                    |
-| [ADR-006](docs/decisions/adr-006-simplified-references.md)   | Simplified References   | Pass by reference, no pointer syntax                         |
-| [ADR-007](docs/decisions/adr-007-type-aware-bit-indexing.md) | Type-Aware Bit Indexing | Integers as bit arrays, `.length` property                   |
-| [ADR-010](docs/decisions/adr-010-c-interoperability.md)      | C Interoperability      | Unified ANTLR parser architecture                            |
-| [ADR-011](docs/decisions/adr-011-vscode-extension.md)        | VS Code Extension       | Live C preview with syntax highlighting                      |
-| [ADR-012](docs/decisions/adr-012-static-analysis.md)         | Static Analysis         | cppcheck integration for generated C                         |
-| [ADR-013](docs/decisions/adr-013-const-qualifier.md)         | Const Qualifier         | Compile-time const enforcement                               |
-| [ADR-014](docs/decisions/adr-014-structs.md)                 | Structs                 | Data containers without methods                              |
-| [ADR-015](docs/decisions/adr-015-null-state.md)              | Null State              | Zero initialization for all variables                        |
-| [ADR-016](docs/decisions/adr-016-scope.md)                   | Scope                   | `this.`/`global.` explicit qualification                     |
-| [ADR-017](docs/decisions/adr-017-enums.md)                   | Enums                   | Type-safe enums with C-style casting                         |
-| [ADR-030](docs/decisions/adr-030-forward-declarations.md)    | Define-Before-Use       | Functions must be defined before called                      |
-| [ADR-037](docs/decisions/adr-037-preprocessor.md)            | Preprocessor            | Flag-only defines, const for values                          |
-| [ADR-043](docs/decisions/adr-043-comments.md)                | Comments                | Comment preservation with MISRA compliance                   |
-| [ADR-044](docs/decisions/adr-044-primitive-types.md)         | Primitive Types         | Fixed-width types with `clamp`/`wrap` overflow               |
-| [ADR-024](docs/decisions/adr-024-type-casting.md)            | Type Casting            | Widening implicit, narrowing uses bit indexing               |
-| [ADR-022](docs/decisions/adr-022-conditional-expressions.md) | Conditional Expressions | Ternary with required parens, boolean condition, no nesting  |
-| [ADR-025](docs/decisions/adr-025-switch-statements.md)       | Switch Statements       | Safe switch with braces, `\|\|` syntax, counted `default(n)` |
-| [ADR-029](docs/decisions/adr-029-function-pointers.md)       | Callbacks               | Function-as-Type pattern with nominal typing                 |
-| [ADR-045](docs/decisions/adr-045-string-type.md)             | Bounded Strings         | `string<N>` with compile-time safety                         |
-| [ADR-023](docs/decisions/adr-023-sizeof.md)                  | Sizeof                  | Type/value size queries with safety checks                   |
-| [ADR-027](docs/decisions/adr-027-do-while.md)                | Do-While                | `do { } while ()` with boolean condition (E0701)             |
-| [ADR-032](docs/decisions/adr-032-nested-structs.md)          | Nested Structs          | Named nested structs only (no anonymous)                     |
-| [ADR-035](docs/decisions/adr-035-array-initializers.md)      | Array Initializers      | `[1, 2, 3]` syntax with `[0*]` fill-all                      |
-| [ADR-036](docs/decisions/adr-036-multidimensional-arrays.md) | Multi-dim Arrays        | `arr[i][j]` with compile-time bounds enforcement             |
-| [ADR-040](docs/decisions/adr-040-isr-declaration.md)         | ISR Type                | Built-in `ISR` type for `void(void)` function pointers       |
-| [ADR-034](docs/decisions/adr-034-bit-fields.md)              | Bitmap Types            | `bitmap8`/`bitmap16`/`bitmap32` for portable bit-packed data |
-| [ADR-048](docs/decisions/adr-048-cli-executable.md)          | CLI Executable          | `cnext` command with smart defaults                          |
-| [ADR-049](docs/decisions/adr-049-atomic-types.md)            | Atomic Types            | `atomic` keyword with LDREX/STREX or PRIMASK fallback        |
-| [ADR-050](docs/decisions/adr-050-critical-sections.md)       | Critical Sections       | `critical { }` blocks with PRIMASK save/restore              |
-| [ADR-108](docs/decisions/adr-108-volatile-keyword.md)        | Volatile Variables      | `volatile` keyword prevents compiler optimization            |
-| [ADR-047](docs/decisions/adr-047-nullable-types.md)          | NULL for C Interop      | `NULL` keyword for C stream function comparisons             |
+| ADR                                                                  | Title                   | Description                                                  |
+| -------------------------------------------------------------------- | ----------------------- | ------------------------------------------------------------ |
+| [ADR-001](docs/decisions/adr-001-assignment-operator.md)             | Assignment Operator     | `<-` for assignment, `=` for comparison                      |
+| [ADR-003](docs/decisions/adr-003-static-allocation.md)               | Static Allocation       | No dynamic memory after init                                 |
+| [ADR-004](docs/decisions/adr-004-register-bindings.md)               | Register Bindings       | Type-safe hardware access                                    |
+| [ADR-006](docs/decisions/adr-006-simplified-references.md)           | Simplified References   | Pass by reference, no pointer syntax                         |
+| [ADR-007](docs/decisions/adr-007-type-aware-bit-indexing.md)         | Type-Aware Bit Indexing | Integers as bit arrays, `.length` property                   |
+| [ADR-010](docs/decisions/adr-010-c-interoperability.md)              | C Interoperability      | Unified ANTLR parser architecture                            |
+| [ADR-011](docs/decisions/adr-011-vscode-extension.md)                | VS Code Extension       | Live C preview with syntax highlighting                      |
+| [ADR-012](docs/decisions/adr-012-static-analysis.md)                 | Static Analysis         | cppcheck integration for generated C                         |
+| [ADR-013](docs/decisions/adr-013-const-qualifier.md)                 | Const Qualifier         | Compile-time const enforcement                               |
+| [ADR-014](docs/decisions/adr-014-structs.md)                         | Structs                 | Data containers without methods                              |
+| [ADR-015](docs/decisions/adr-015-null-state.md)                      | Null State              | Zero initialization for all variables                        |
+| [ADR-016](docs/decisions/adr-016-scope.md)                           | Scope                   | `this.`/`global.` explicit qualification                     |
+| [ADR-017](docs/decisions/adr-017-enums.md)                           | Enums                   | Type-safe enums with C-style casting                         |
+| [ADR-030](docs/decisions/adr-030-forward-declarations.md)            | Define-Before-Use       | Functions must be defined before called                      |
+| [ADR-037](docs/decisions/adr-037-preprocessor.md)                    | Preprocessor            | Flag-only defines, const for values                          |
+| [ADR-043](docs/decisions/adr-043-comments.md)                        | Comments                | Comment preservation with MISRA compliance                   |
+| [ADR-044](docs/decisions/adr-044-primitive-types.md)                 | Primitive Types         | Fixed-width types with `clamp`/`wrap` overflow               |
+| [ADR-024](docs/decisions/adr-024-type-casting.md)                    | Type Casting            | Widening implicit, narrowing uses bit indexing               |
+| [ADR-022](docs/decisions/adr-022-conditional-expressions.md)         | Conditional Expressions | Ternary with required parens, boolean condition, no nesting  |
+| [ADR-025](docs/decisions/adr-025-switch-statements.md)               | Switch Statements       | Safe switch with braces, `\|\|` syntax, counted `default(n)` |
+| [ADR-029](docs/decisions/adr-029-function-pointers.md)               | Callbacks               | Function-as-Type pattern with nominal typing                 |
+| [ADR-045](docs/decisions/adr-045-string-type.md)                     | Bounded Strings         | `string<N>` with compile-time safety                         |
+| [ADR-023](docs/decisions/adr-023-sizeof.md)                          | Sizeof                  | Type/value size queries with safety checks                   |
+| [ADR-027](docs/decisions/adr-027-do-while.md)                        | Do-While                | `do { } while ()` with boolean condition (E0701)             |
+| [ADR-032](docs/decisions/adr-032-nested-structs.md)                  | Nested Structs          | Named nested structs only (no anonymous)                     |
+| [ADR-035](docs/decisions/adr-035-array-initializers.md)              | Array Initializers      | `[1, 2, 3]` syntax with `[0*]` fill-all                      |
+| [ADR-036](docs/decisions/adr-036-multidimensional-arrays.md)         | Multi-dim Arrays        | `arr[i][j]` with compile-time bounds enforcement             |
+| [ADR-040](docs/decisions/adr-040-isr-declaration.md)                 | ISR Type                | Built-in `ISR` type for `void(void)` function pointers       |
+| [ADR-034](docs/decisions/adr-034-bit-fields.md)                      | Bitmap Types            | `bitmap8`/`bitmap16`/`bitmap32` for portable bit-packed data |
+| [ADR-048](docs/decisions/adr-048-cli-executable.md)                  | CLI Executable          | `cnext` command with smart defaults                          |
+| [ADR-049](docs/decisions/adr-049-atomic-types.md)                    | Atomic Types            | `atomic` keyword with LDREX/STREX or PRIMASK fallback        |
+| [ADR-050](docs/decisions/adr-050-critical-sections.md)               | Critical Sections       | `critical { }` blocks with PRIMASK save/restore              |
+| [ADR-108](docs/decisions/adr-108-volatile-keyword.md)                | Volatile Variables      | `volatile` keyword prevents compiler optimization            |
+| [ADR-047](docs/decisions/adr-047-nullable-types.md)                  | NULL for C Interop      | `NULL` keyword for C stream function comparisons             |
+| [ADR-052](docs/decisions/adr-052-safe-numeric-literal-generation.md) | Safe Numeric Literals   | `type_MIN`/`type_MAX` constants + safe hex conversion        |
 
 ### Research (v1 Roadmap)
 
@@ -736,19 +737,41 @@ Decisions are documented in `/docs/decisions/`:
 | [ADR-031](docs/decisions/adr-031-inline-functions.md)            | Inline Functions    | Trust compiler; `inline` is just a hint anyway                          |
 | [ADR-033](docs/decisions/adr-033-packed-structs.md)              | Packed Structs      | Use ADR-004 register bindings or explicit serialization                 |
 
-## Development Commands
+## Development
+
+### Setup
+
+```bash
+# Clone and install (IMPORTANT: npm install sets up pre-commit hooks)
+git clone https://github.com/jlaustill/c-next.git
+cd c-next
+npm install  # Installs dependencies and Husky pre-commit hooks
+```
+
+**Pre-commit hooks:** The project uses [Husky](https://typicode.github.io/husky/) to automatically format code (Prettier) and fix linting (ESLint) before every commit. This prevents formatting errors in PRs.
+
+### Commands
 
 ```bash
 npm run antlr      # Regenerate parser from grammar
 npm run typecheck  # Type-check TypeScript (no build required)
-npm test           # Run all tests
+npm test                              # Run all tests
+npm test -- --quiet                   # Minimal output (errors + summary only)
+npm test -- tests/enum                # Run specific directory
+npm test -- tests/enum/my.test.cnx    # Run single test file
+
+# Code quality (auto-run by pre-commit hooks)
+npm run prettier:fix   # Format all code
+npm run eslint:check   # Check for lint errors
 ```
 
 **Note:** C-Next runs directly via `tsx` without a build step. The `typecheck` command validates types only and does not generate any output files.
 
 ## Contributing
 
-Ideas and feedback welcome via issues.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the complete development workflow, testing requirements, and PR process.
+
+**Quick start:** Ideas and feedback welcome via issues.
 
 ## License
 

package/grammar/CNext.g4

@@ -345,8 +345,8 @@ switchCase
 caseLabel
     : qualifiedType      // Enum value: EState.IDLE
     | IDENTIFIER         // Const or enum member
-    | INTEGER_LITERAL
-    | HEX_LITERAL
+    | '-'? INTEGER_LITERAL  // Allow negative integers
+    | '-'? HEX_LITERAL      // Allow negative hex (e.g., -0x80)
     | BINARY_LITERAL
     | CHAR_LITERAL
     ;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {
@@ -16,17 +16,17 @@
     "start": "tsx src/index.ts",
     "dev": "tsx src/index.ts",
     "typecheck": "tsc --noEmit",
-    "test": "tsx scripts/test.js",
+    "test": "tsx scripts/test.ts",
     "test:cli": "node scripts/test-cli.js",
-    "test:update": "tsx scripts/test.js --update",
+    "test:update": "tsx scripts/test.ts --update",
     "analyze": "./scripts/static-analysis.sh",
     "clean": "rm -rf src/parser",
     "prettier:check": "prettier --check .",
     "prettier:fix": "prettier --write .",
-    "eslint:check": "eslint src/",
-    "eslint:fix": "eslint src/ --fix",
+    "oxlint:check": "oxlint src/",
+    "oxlint:fix": "oxlint src/ --fix",
     "prepare": "husky",
-    "prepublishOnly": "npm run prettier:check && npm run eslint:check && npm test"
+    "prepublishOnly": "npm run prettier:check && npm run oxlint:check && npm test"
   },
   "keywords": [
     "c",
@@ -57,16 +57,11 @@
   ],
   "devDependencies": {
     "@types/node": "^25.0.3",
-    "@typescript-eslint/eslint-plugin": "^7.18.0",
-    "@typescript-eslint/parser": "^7.18.0",
     "antlr4ng-cli": "^2.0.0",
-    "eslint": "^8.57.1",
-    "eslint-config-airbnb-typescript": "^18.0.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-import": "^2.32.0",
     "husky": "^9.1.7",
     "jest": "^30.2.0",
     "lint-staged": "^16.2.7",
+    "oxlint": "^1.39.0",
     "prettier": "^3.7.4",
     "ts-jest": "^29.4.6"
   },
@@ -80,7 +75,7 @@
       "prettier --write --ignore-unknown"
     ],
     "*.ts": [
-      "eslint --fix"
+      "oxlint --fix"
     ]
   }
 }

package/src/analysis/DivisionByZeroAnalyzer.ts

@@ -13,7 +13,7 @@
 import { ParseTreeWalker } from "antlr4ng";
 import { CNextListener } from "../parser/grammar/CNextListener";
 import * as Parser from "../parser/grammar/CNextParser";
-import { IDivisionByZeroError } from "./types/IDivisionByZeroError";
+import IDivisionByZeroError from "./types/IDivisionByZeroError";
 
 /**
  * First pass: Collect const declarations that are zero
@@ -323,7 +323,7 @@ class DivisionByZeroListener extends CNextListener {
 /**
  * Analyzer that detects division by zero
  */
-export class DivisionByZeroAnalyzer {
+class DivisionByZeroAnalyzer {
   private errors: IDivisionByZeroError[] = [];
 
   /**

package/src/analysis/FloatModuloAnalyzer.ts

@@ -0,0 +1,196 @@
+/**
+ * Float Modulo Analyzer
+ * Detects modulo operator usage with floating-point types at compile time
+ *
+ * The modulo operator (%) is only valid for integer types in C.
+ * C-Next catches this early with a clear error message.
+ *
+ * Two-pass analysis:
+ * 1. Collect variable declarations with f32/f64 types
+ * 2. Detect modulo operations using float variables or literals
+ */
+
+import { ParseTreeWalker } from "antlr4ng";
+import { CNextListener } from "../parser/grammar/CNextListener";
+import * as Parser from "../parser/grammar/CNextParser";
+import IFloatModuloError from "./types/IFloatModuloError";
+
+const FLOAT_TYPES = ["f32", "f64", "float", "double"];
+
+/**
+ * First pass: Collect variable declarations with float types
+ */
+class FloatVariableCollector extends CNextListener {
+  private floatVars: Set<string> = new Set();
+
+  public getFloatVars(): Set<string> {
+    return this.floatVars;
+  }
+
+  /**
+   * Track variable declarations with f32/f64 types
+   */
+  override enterVariableDeclaration = (
+    ctx: Parser.VariableDeclarationContext,
+  ): void => {
+    const typeCtx = ctx.type();
+    if (!typeCtx) return;
+
+    const typeName = typeCtx.getText();
+    if (!FLOAT_TYPES.includes(typeName)) return;
+
+    const identifier = ctx.IDENTIFIER();
+    if (!identifier) return;
+
+    this.floatVars.add(identifier.getText());
+  };
+
+  /**
+   * Track function parameters with f32/f64 types
+   */
+  override enterParameter = (ctx: Parser.ParameterContext): void => {
+    const typeCtx = ctx.type();
+    if (!typeCtx) return;
+
+    const typeName = typeCtx.getText();
+    if (!FLOAT_TYPES.includes(typeName)) return;
+
+    const identifier = ctx.IDENTIFIER();
+    if (!identifier) return;
+
+    this.floatVars.add(identifier.getText());
+  };
+}
+
+/**
+ * Second pass: Detect modulo operations with float operands
+ */
+class FloatModuloListener extends CNextListener {
+  private analyzer: FloatModuloAnalyzer;
+
+  // eslint-disable-next-line @typescript-eslint/lines-between-class-members
+  private floatVars: Set<string>;
+
+  constructor(analyzer: FloatModuloAnalyzer, floatVars: Set<string>) {
+    super();
+    this.analyzer = analyzer;
+    this.floatVars = floatVars;
+  }
+
+  /**
+   * Check multiplicative expressions for modulo with float operands
+   * multiplicativeExpression: unaryExpression (('*' | '/' | '%') unaryExpression)*
+   */
+  override enterMultiplicativeExpression = (
+    ctx: Parser.MultiplicativeExpressionContext,
+  ): void => {
+    const operands = ctx.unaryExpression();
+    if (operands.length < 2) return;
+
+    // Check each operator
+    for (let i = 0; i < operands.length - 1; i++) {
+      const operatorToken = ctx.getChild(i * 2 + 1);
+      if (!operatorToken) continue;
+
+      const operator = operatorToken.getText();
+      if (operator !== "%") continue;
+
+      const leftOperand = operands[i];
+      const rightOperand = operands[i + 1];
+
+      const leftIsFloat = this.isFloatOperand(leftOperand);
+      const rightIsFloat = this.isFloatOperand(rightOperand);
+
+      if (leftIsFloat || rightIsFloat) {
+        const line = leftOperand.start?.line ?? 0;
+        const column = leftOperand.start?.column ?? 0;
+        this.analyzer.addError(line, column);
+      }
+    }
+  };
+
+  /**
+   * Check if a unary expression is a float type
+   */
+  private isFloatOperand(ctx: Parser.UnaryExpressionContext): boolean {
+    const postfixExpr = ctx.postfixExpression();
+    if (!postfixExpr) return false;
+
+    const primaryExpr = postfixExpr.primaryExpression();
+    if (!primaryExpr) return false;
+
+    // Check for float literal
+    const literal = primaryExpr.literal();
+    if (literal) {
+      return this.isFloatLiteral(literal);
+    }
+
+    // Check for identifier that's a float variable
+    const identifier = primaryExpr.IDENTIFIER();
+    if (identifier) {
+      return this.floatVars.has(identifier.getText());
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if a literal is a floating-point number
+   */
+  private isFloatLiteral(ctx: Parser.LiteralContext): boolean {
+    // Check for FLOAT_LITERAL token
+    if (ctx.FLOAT_LITERAL()) return true;
+
+    // Check text for decimal point (fallback)
+    const text = ctx.getText();
+    return text.includes(".") && !text.startsWith('"');
+  }
+}
+
+/**
+ * Analyzer that detects modulo operations with floating-point types
+ */
+class FloatModuloAnalyzer {
+  private errors: IFloatModuloError[] = [];
+
+  /**
+   * Analyze the parse tree for float modulo operations
+   */
+  public analyze(tree: Parser.ProgramContext): IFloatModuloError[] {
+    this.errors = [];
+
+    // First pass: collect float variables
+    const collector = new FloatVariableCollector();
+    ParseTreeWalker.DEFAULT.walk(collector, tree);
+    const floatVars = collector.getFloatVars();
+
+    // Second pass: detect modulo with floats
+    const listener = new FloatModuloListener(this, floatVars);
+    ParseTreeWalker.DEFAULT.walk(listener, tree);
+
+    return this.errors;
+  }
+
+  /**
+   * Add a float modulo error
+   */
+  public addError(line: number, column: number): void {
+    this.errors.push({
+      code: "E0804",
+      line,
+      column,
+      message: "Modulo operator not supported for floating-point types",
+      helpText:
+        "The % operator only works with integer types. Use fmod() from <math.h> for floating-point remainder.",
+    });
+  }
+
+  /**
+   * Get all detected errors
+   */
+  public getErrors(): IFloatModuloError[] {
+    return this.errors;
+  }
+}
+
+export default FloatModuloAnalyzer;

package/src/analysis/FunctionCallAnalyzer.ts

@@ -13,9 +13,7 @@ import * as Parser from "../parser/grammar/CNextParser";
 import SymbolTable from "../symbols/SymbolTable";
 import ESourceLanguage from "../types/ESourceLanguage";
 import ESymbolKind from "../types/ESymbolKind";
-import { IFunctionCallError } from "./types/IFunctionCallError";
-
-export { IFunctionCallError };
+import IFunctionCallError from "./types/IFunctionCallError";
 
 /**
  * C-Next built-in functions
@@ -341,7 +339,7 @@ class FunctionCallListener extends CNextListener {
 /**
  * Analyzes C-Next AST for function calls before definition
  */
-export class FunctionCallAnalyzer {
+class FunctionCallAnalyzer {
   private errors: IFunctionCallError[] = [];
 
   /** Functions that have been defined (in order of appearance) */

package/src/analysis/InitializationAnalyzer.ts

@@ -14,10 +14,8 @@
 import { ParseTreeWalker } from "antlr4ng";
 import { CNextListener } from "../parser/grammar/CNextListener";
 import * as Parser from "../parser/grammar/CNextParser";
-import {
-  IInitializationError,
-  IDeclarationInfo,
-} from "./types/IInitializationError";
+import IInitializationError from "./types/IInitializationError";
+import IDeclarationInfo from "./types/IDeclarationInfo";
 
 /**
  * Tracks the initialization state of a variable
@@ -156,14 +154,19 @@ class InitializationListener extends CNextListener {
       this.analyzer.recordAssignment(name);
     }
 
-    // Member access: p.x <- value (only first-level field)
+    // Member access: p.x <- value (struct field) or arr[i][j] <- value (multi-dim array)
     if (targetCtx.memberAccess()) {
       const memberCtx = targetCtx.memberAccess()!;
       const identifiers = memberCtx.IDENTIFIER();
       if (identifiers.length >= 2) {
+        // Struct field access: p.x <- value
         const varName = identifiers[0].getText();
         const fieldName = identifiers[1].getText();
         this.analyzer.recordAssignment(varName, fieldName);
+      } else if (identifiers.length === 1) {
+        // Multi-dimensional array access: arr[i][j] <- value
+        const varName = identifiers[0].getText();
+        this.analyzer.recordAssignment(varName);
       }
     }
 
@@ -346,11 +349,54 @@ class InitializationListener extends CNextListener {
     this.savedStates.push(this.analyzer.cloneScopeState());
   };
 
-  override exitForStatement = (_ctx: Parser.ForStatementContext): void => {
-    // Same as while - conservative approach
+  /**
+   * Check if a for-loop is deterministic (will definitely run at least once)
+   * A loop is deterministic if it has the form: for (var <- 0; var < CONSTANT; ...)
+   * where CONSTANT > 0
+   */
+  private isDeterministicForLoop(ctx: Parser.ForStatementContext): boolean {
+    const init = ctx.forInit();
+    const cond = ctx.expression();
+
+    if (!init || !cond) return false;
+
+    // Check if init is a variable declaration starting at 0
+    const forVarDecl = init.forVarDecl();
+    if (forVarDecl) {
+      const initExpr = forVarDecl.expression();
+      if (!initExpr) return false;
+      const initText = initExpr.getText();
+      if (initText !== "0") return false;
+    } else {
+      // forAssignment case: check if assigning 0
+      const forAssign = init.forAssignment();
+      if (!forAssign) return false;
+      const assignExpr = forAssign.expression();
+      if (!assignExpr) return false;
+      const assignText = assignExpr.getText();
+      if (assignText !== "0") return false;
+    }
+
+    // Check if condition is var < POSITIVE_CONSTANT
+    const condText = cond.getText();
+    // Match patterns like "i<4" or "ti<3" (no spaces in AST getText())
+    const match = condText.match(/^\w+<(\d+)$/);
+    if (!match) return false;
+    const bound = parseInt(match[1], 10);
+    return bound > 0;
+  }
+
+  override exitForStatement = (ctx: Parser.ForStatementContext): void => {
     const stateBeforeLoop = this.savedStates.pop();
     if (stateBeforeLoop) {
-      this.analyzer.restoreFromState(stateBeforeLoop);
+      const isDeterministic = this.isDeterministicForLoop(ctx);
+      if (isDeterministic) {
+        // Deterministic loop - preserve initialization (loop WILL run)
+        this.analyzer.mergeInitializationState(stateBeforeLoop);
+      } else {
+        // Non-deterministic loop - conservative restore (loop might not run)
+        this.analyzer.restoreFromState(stateBeforeLoop);
+      }
     }
   };
 }
@@ -358,7 +404,7 @@ class InitializationListener extends CNextListener {
 /**
  * Analyzes C-Next AST for use-before-initialization errors
  */
-export class InitializationAnalyzer {
+class InitializationAnalyzer {
   private errors: IInitializationError[] = [];
 
   private currentScope: IScope | null = null;
@@ -653,6 +699,32 @@ export class InitializationAnalyzer {
     }
   }
 
+  /**
+   * Merge initialization state from a saved snapshot
+   * Used for deterministic loops where initialization inside the loop
+   * should be preserved (the loop WILL run at least once)
+   */
+  public mergeInitializationState(
+    beforeState: Map<string, IVariableState>,
+  ): void {
+    let scope = this.currentScope;
+    while (scope) {
+      for (const [name, currentState] of scope.variables) {
+        const beforeVar = beforeState.get(name);
+        if (beforeVar) {
+          // Preserve initialization if it happened inside the loop
+          // (currentState.initialized stays true if set inside loop)
+          // Merge initializedFields from before state to preserve any
+          // fields that were initialized before the loop
+          for (const field of beforeVar.initializedFields) {
+            currentState.initializedFields.add(field);
+          }
+        }
+      }
+      scope = scope.parent;
+    }
+  }
+
   // ========================================================================
   // Error Reporting
   // ========================================================================

package/src/analysis/NullCheckAnalyzer.ts

@@ -16,9 +16,7 @@
 import { ParseTreeWalker } from "antlr4ng";
 import { CNextListener } from "../parser/grammar/CNextListener";
 import * as Parser from "../parser/grammar/CNextParser";
-import { INullCheckError } from "./types/INullCheckError";
-
-export { INullCheckError };
+import INullCheckError from "./types/INullCheckError";
 
 /**
  * Metadata for C library functions that can return NULL
@@ -284,7 +282,7 @@ class NullCheckListener extends CNextListener {
 /**
  * Analyzes C-Next AST for NULL safety violations
  */
-export class NullCheckAnalyzer {
+class NullCheckAnalyzer {
   private errors: INullCheckError[] = [];
 
   /** Included headers (for context) */

package/src/analysis/types/IDeclarationInfo.ts

@@ -0,0 +1,13 @@
+/**
+ * Information about where a variable was declared
+ */
+interface IDeclarationInfo {
+  /** Variable name */
+  name: string;
+  /** Line where variable was declared */
+  line: number;
+  /** Column where variable was declared */
+  column: number;
+}
+
+export default IDeclarationInfo;

package/src/analysis/types/IDivisionByZeroError.ts

@@ -7,7 +7,7 @@
  * - E0802: Modulo by literal zero
  * - E0803: Modulo by const that evaluates to zero
  */
-export interface IDivisionByZeroError {
+interface IDivisionByZeroError {
   /** Error code (E0800-E0803) */
   code: string;
   /** Operator used ('/' or '%') */

package/src/analysis/types/IFloatModuloError.ts

@@ -0,0 +1,20 @@
+/**
+ * Error reported when modulo operator is used with floating-point types
+ *
+ * Error codes:
+ * - E0804: Modulo operator used with floating-point operand
+ */
+interface IFloatModuloError {
+  /** Error code (E0804) */
+  code: string;
+  /** Line number where the error occurred */
+  line: number;
+  /** Column number where the error occurred */
+  column: number;
+  /** Human-readable error message */
+  message: string;
+  /** Optional help text with suggested fix */
+  helpText?: string;
+}
+
+export default IFloatModuloError;

package/src/analysis/types/IFunctionCallError.ts

@@ -1,7 +1,7 @@
 /**
  * Error reported when a function is called before it's defined (ADR-030)
  */
-export interface IFunctionCallError {
+interface IFunctionCallError {
   /** Error code (E0422) */
   code: string;
   /** Name of the function that was called */