c-next 0.1.1 → 0.1.3

package/README.md

@@ -301,6 +301,40 @@ Write-only registers generate optimized code:
 GPIO7.DR_SET[LED_BIT] <- true;    // Generates: GPIO7_DR_SET = (1 << LED_BIT);
 ```
 
+### Slice Assignment for Memory Operations
+
+Multi-byte copying with bounds-checked `memcpy` generation:
+
+```cnx
+u8 buffer[256];
+u32 magic <- 0x12345678;
+u8 length <- 4;
+u32 offset <- 0;
+
+// Copy 4 bytes from value into buffer at offset
+buffer[offset, length] <- magic;
+```
+
+Transpiles to runtime bounds-checked code:
+
+```c
+uint8_t buffer[256] = {0};
+uint32_t magic = 0x12345678;
+uint8_t length = 4;
+uint32_t offset = 0;
+
+if (offset + length <= sizeof(buffer)) {
+    memcpy(&buffer[offset], &magic, length);
+}
+```
+
+**Key Features:**
+
+- Runtime bounds checking prevents buffer overflows
+- Enables binary serialization and protocol implementation
+- Works with struct fields: `buffer[offset, len] <- config.magic`
+- Distinct from bit operations: array slices use `memcpy`, scalar bit ranges use bit manipulation
+
 ### Scopes (ADR-016)
 
 Organize code with automatic name prefixing. Inside scopes, explicit qualification is required:
@@ -702,17 +736,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                 |
 
-## Build 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 build      # Full build: ANTLR + TypeScript
 npm run antlr      # Regenerate parser from grammar
-npx tsc            # TypeScript only
+npm run typecheck  # Type-check TypeScript (no build required)
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {
@@ -15,17 +15,18 @@
     "antlr:all": "npm run antlr && npm run antlr:c && npm run antlr:cpp",
     "start": "tsx src/index.ts",
     "dev": "tsx src/index.ts",
-    "test": "tsx scripts/test.js",
+    "typecheck": "tsc --noEmit",
+    "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",
@@ -56,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"
   },
@@ -79,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 */

package/src/analysis/types/IInitializationError.ts

@@ -3,22 +3,12 @@
  * Used for Rust-style "use before initialization" detection
  */
 
-/**
- * Information about where a variable was declared
- */
-export interface IDeclarationInfo {
-  /** Variable name */
-  name: string;
-  /** Line where variable was declared */
-  line: number;
-  /** Column where variable was declared */
-  column: number;
-}
+import IDeclarationInfo from "./IDeclarationInfo";
 
 /**
  * Error for using a variable before initialization
  */
-export interface IInitializationError {
+interface IInitializationError {
   /** Error code (E0381 matches Rust's error code) */
   code: "E0381";
   /** The variable or field that was used before initialization */
@@ -35,21 +25,4 @@ export interface IInitializationError {
   message: string;
 }
 
-/**
- * Format an initialization error into a Rust-style error message
- */
-export function formatInitializationError(error: IInitializationError): string {
-  const certainty = error.mayBeUninitialized ? "possibly " : "";
-  return `error[${error.code}]: use of ${certainty}uninitialized variable '${error.variable}'
-  --> line ${error.line}:${error.column}
-   |
-${error.declaration.line} |     ${error.declaration.name}
-   |         - variable declared here
-...
-${error.line} |     ${error.variable}
-   |     ^ use of ${certainty}uninitialized '${error.variable}'
-   |
-   = help: consider initializing '${error.variable}'`;
-}
-
 export default IInitializationError;

package/src/analysis/types/INullCheckError.ts

@@ -7,7 +7,7 @@
  * - E0903: NULL can only be used in comparison context
  * - E0904: Cannot store C function pointer return in variable
  */
-export interface INullCheckError {
+interface INullCheckError {
   /** Error code (E0901-E0904) */
   code: string;
   /** Name of the function or literal involved */

package/src/analysis/types/formatInitializationError.ts

@@ -0,0 +1,20 @@
+import IInitializationError from "./IInitializationError";
+
+/**
+ * Format an initialization error into a Rust-style error message
+ */
+function formatInitializationError(error: IInitializationError): string {
+  const certainty = error.mayBeUninitialized ? "possibly " : "";
+  return `error[${error.code}]: use of ${certainty}uninitialized variable '${error.variable}'
+  --> line ${error.line}:${error.column}
+   |
+${error.declaration.line} |     ${error.declaration.name}
+   |         - variable declared here
+...
+${error.line} |     ${error.variable}
+   |     ^ use of ${certainty}uninitialized '${error.variable}'
+   |
+   = help: consider initializing '${error.variable}'`;
+}
+
+export default formatInitializationError;