c-next 0.1.8 → 0.1.10

package/README.md

@@ -303,36 +303,38 @@ 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:
+Multi-byte copying with compile-time validated `memcpy` generation (Issue #234):
 
 ```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;
+// Copy 4 bytes from value into buffer at offset 0
+buffer[0, 4] <- magic;
+
+// Named offsets using const variables
+const u32 HEADER_OFFSET <- 0;
+const u32 DATA_OFFSET <- 8;
+buffer[HEADER_OFFSET, 4] <- magic;
+buffer[DATA_OFFSET, 8] <- timestamp;
 ```
 
-Transpiles to runtime bounds-checked code:
+Transpiles to direct memcpy (bounds validated at compile time):
 
 ```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);
-}
+memcpy(&buffer[0], &magic, 4);
+memcpy(&buffer[8], &timestamp, 8);
 ```
 
 **Key Features:**
 
-- Runtime bounds checking prevents buffer overflows
-- Enables binary serialization and protocol implementation
-- Works with struct fields: `buffer[offset, len] <- config.magic`
+- **Compile-time bounds checking** prevents buffer overflows at compile time
+- Offset and length must be compile-time constants (literals or `const` variables)
+- Silent runtime failures are now compile-time errors
+- Works with struct fields: `buffer[0, 4] <- config.magic`
 - Distinct from bit operations: array slices use `memcpy`, scalar bit ranges use bit manipulation
 
 ### Scopes (ADR-016)
@@ -773,6 +775,26 @@ npm run coverage:grammar:check   # Grammar coverage with threshold check (CI)
 
 **Note:** C-Next runs directly via `tsx` without a build step. The `typecheck` command validates types only and does not generate any output files.
 
+### Formatting C-Next Files
+
+The project includes a Prettier plugin for formatting `.cnx` files with consistent style (4-space indentation, same-line braces).
+
+```bash
+# Format a single file
+npx prettier --plugin ./prettier-plugin/dist/index.js --write myfile.cnx
+
+# Format all .cnx files in tests/
+npx prettier --plugin ./prettier-plugin/dist/index.js --write "tests/**/*.cnx"
+```
+
+To build the plugin from source (after making changes):
+
+```bash
+cd prettier-plugin
+npm install
+npm run build
+```
+
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for the complete development workflow, testing requirements, and PR process.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {
@@ -34,7 +34,10 @@
     "coverage:ids": "tsx scripts/coverage-checker.ts ids",
     "coverage:grammar": "tsx scripts/grammar-coverage.ts report",
     "coverage:grammar:check": "tsx scripts/grammar-coverage.ts check",
-    "coverage:grammar:console": "tsx scripts/grammar-coverage.ts console"
+    "coverage:grammar:console": "tsx scripts/grammar-coverage.ts console",
+    "unit": "vitest run",
+    "unit:watch": "vitest",
+    "test:all": "npm run unit && npm run test:q"
   },
   "keywords": [
     "c",
@@ -67,11 +70,10 @@
     "@types/node": "^25.0.3",
     "antlr4ng-cli": "^2.0.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"
+    "vitest": "^3.0.0"
   },
   "dependencies": {
     "antlr4ng": "^3.0.16",

package/src/analysis/ParameterNamingAnalyzer.ts

@@ -0,0 +1,121 @@
+/**
+ * Parameter Naming Analyzer
+ * Issue #227: Validates that function parameters don't use reserved naming patterns
+ *
+ * Parameters cannot start with their containing function's name followed by underscore.
+ * This naming pattern is reserved for scope-level variables and would bypass the
+ * conflict detection heuristic in SymbolTable.detectConflict().
+ */
+
+import { ParseTreeWalker } from "antlr4ng";
+import { CNextListener } from "../parser/grammar/CNextListener";
+import * as Parser from "../parser/grammar/CNextParser";
+import IParameterNamingError from "./types/IParameterNamingError";
+
+/**
+ * Pure function to check if a parameter name uses a reserved pattern
+ *
+ * @param parameterName - The parameter name to check
+ * @param functionName - The name of the containing function (without scope prefix)
+ * @returns true if the parameter name is problematic
+ */
+function isReservedParameterName(
+  parameterName: string,
+  functionName: string,
+): boolean {
+  return parameterName.startsWith(functionName + "_");
+}
+
+/**
+ * Pure function to create the error message
+ *
+ * @param parameterName - The parameter name
+ * @param functionName - The containing function name
+ * @returns The formatted error message
+ */
+function formatParameterNamingError(
+  parameterName: string,
+  functionName: string,
+): string {
+  return (
+    `Parameter '${parameterName}' cannot start with function name prefix ` +
+    `'${functionName}_'. This naming pattern is reserved for scope-level variables.`
+  );
+}
+
+/**
+ * Listener that walks the parse tree to find parameter naming violations
+ */
+class ParameterNamingListener extends CNextListener {
+  private analyzer: ParameterNamingAnalyzer;
+
+  constructor(analyzer: ParameterNamingAnalyzer) {
+    super();
+    this.analyzer = analyzer;
+  }
+
+  override enterFunctionDeclaration = (
+    ctx: Parser.FunctionDeclarationContext,
+  ): void => {
+    const functionName = ctx.IDENTIFIER().getText();
+    const paramList = ctx.parameterList();
+
+    if (paramList) {
+      for (const param of paramList.parameter()) {
+        const paramIdentifier = param.IDENTIFIER();
+        const paramName = paramIdentifier.getText();
+        // Use the identifier's position for more precise error location
+        const line = paramIdentifier.symbol.line;
+        const column = paramIdentifier.symbol.column;
+
+        if (isReservedParameterName(paramName, functionName)) {
+          this.analyzer.addError(paramName, functionName, line, column);
+        }
+      }
+    }
+  };
+}
+
+/**
+ * Analyzer for parameter naming violations
+ */
+class ParameterNamingAnalyzer {
+  private errors: IParameterNamingError[] = [];
+
+  /**
+   * Analyze the parse tree for parameter naming violations
+   *
+   * @param tree - The parsed program AST
+   * @returns Array of errors (empty if all pass)
+   */
+  public analyze(tree: Parser.ProgramContext): IParameterNamingError[] {
+    this.errors = [];
+
+    const listener = new ParameterNamingListener(this);
+    ParseTreeWalker.DEFAULT.walk(listener, tree);
+
+    return this.errors;
+  }
+
+  /**
+   * Add a parameter naming error
+   */
+  public addError(
+    parameterName: string,
+    functionName: string,
+    line: number,
+    column: number,
+  ): void {
+    this.errors.push({
+      code: "E0227",
+      parameterName,
+      functionName,
+      line,
+      column,
+      message: formatParameterNamingError(parameterName, functionName),
+      helpText: `Consider renaming to a name that doesn't start with '${functionName}_'`,
+    });
+  }
+}
+
+export default ParameterNamingAnalyzer;

package/src/analysis/types/IParameterNamingError.ts

@@ -0,0 +1,22 @@
+/**
+ * Error reported when a function parameter has a reserved naming pattern
+ * Issue #227: Parameters cannot start with their function name followed by underscore
+ */
+interface IParameterNamingError {
+  /** Error code (E0227) - matches issue number */
+  code: string;
+  /** Name of the parameter */
+  parameterName: string;
+  /** Name of the containing function */
+  functionName: string;
+  /** Line number where the parameter is declared */
+  line: number;
+  /** Column number where the parameter is declared */
+  column: number;
+  /** Human-readable error message */
+  message: string;
+  /** Optional help text with suggested fix */
+  helpText?: string;
+}
+
+export default IParameterNamingError;

package/src/codegen/CodeGenerator.ts

@@ -1131,6 +1131,20 @@ export default class CodeGenerator implements IOrchestrator {
     output.push(" */");
     output.push("");
 
+    // Issue #230: Self-include for extern "C" linkage
+    // When file has public symbols and headers are being generated,
+    // include own header to ensure proper C linkage
+    if (
+      options?.generateHeaders &&
+      this.symbols!.hasPublicSymbols() &&
+      this.sourcePath
+    ) {
+      const basename = this.sourcePath.replace(/^.*[\\/]/, "");
+      const headerName = basename.replace(/\.cnx$|\.cnext$/, ".h");
+      output.push(`#include "${headerName}"`);
+      output.push("");
+    }
+
     // Pass through #include directives from source
     // C-Next does NOT hardcode any libraries - all includes must be explicit
     // ADR-043: Comments before first include become file-level comments
@@ -5603,9 +5617,43 @@ export default class CodeGenerator implements IOrchestrator {
       if (isActualArray || isISRType) {
         // Check for slice assignment: array[offset, length] <- value
         if (exprs.length === 2) {
-          // Slice assignment - generate memcpy with bounds checking
-          const offset = this._generateExpression(exprs[0]);
-          const length = this._generateExpression(exprs[1]);
+          // Issue #234: Slice assignment requires compile-time constant offset and length
+          // to ensure bounds safety at compile time, not runtime
+          const offsetValue = this._tryEvaluateConstant(exprs[0]);
+          const lengthValue = this._tryEvaluateConstant(exprs[1]);
+
+          const line = exprs[0].start?.line ?? arrayAccessCtx.start?.line ?? 0;
+
+          // Issue #234: Reject slice assignment on multi-dimensional arrays
+          // Slice assignment is only valid on 1D arrays (the innermost dimension)
+          // For multi-dimensional arrays like board[4][8], use board[row][offset, length]
+          // (Note: grammar currently doesn't support this - tracked as future work)
+          if (
+            typeInfo?.arrayDimensions &&
+            typeInfo.arrayDimensions.length > 1
+          ) {
+            throw new Error(
+              `${line}:0 Error: Slice assignment is only valid on one-dimensional arrays. ` +
+                `'${name}' has ${typeInfo.arrayDimensions.length} dimensions. ` +
+                `Access the innermost dimension first (e.g., ${name}[index][offset, length]).`,
+            );
+          }
+
+          // Validate offset is compile-time constant
+          if (offsetValue === undefined) {
+            throw new Error(
+              `${line}:0 Error: Slice assignment offset must be a compile-time constant. ` +
+                `Runtime offsets are not allowed to ensure bounds safety.`,
+            );
+          }
+
+          // Validate length is compile-time constant
+          if (lengthValue === undefined) {
+            throw new Error(
+              `${line}:0 Error: Slice assignment length must be a compile-time constant. ` +
+                `Runtime lengths are not allowed to ensure bounds safety.`,
+            );
+          }
 
           // Compound operators not supported for slice assignment
           if (cOp !== "=") {
@@ -5614,22 +5662,50 @@ export default class CodeGenerator implements IOrchestrator {
             );
           }
 
-          // Set flag to include string.h for memcpy
-          this.needsString = true;
-
-          // Generate bounds-checked memcpy
-          // if (offset + length <= sizeof(buffer)) { memcpy(&buffer[offset], &value, length); }
-          // Issue #213: For string parameters, use capacity for bounds checking
-          // since sizeof(char*) gives pointer size, not buffer size
+          // Determine buffer capacity for compile-time bounds check
+          let capacity: number;
           if (
             typeInfo?.isString &&
             typeInfo.stringCapacity &&
             !typeInfo.isArray
           ) {
-            const capacity = typeInfo.stringCapacity + 1;
-            return `if (${offset} + ${length} <= ${capacity}) { memcpy(&${name}[${offset}], &${value}, ${length}); }`;
+            capacity = typeInfo.stringCapacity + 1;
+          } else if (typeInfo?.arrayDimensions && typeInfo.arrayDimensions[0]) {
+            capacity = typeInfo.arrayDimensions[0];
+          } else {
+            // Can't determine capacity at compile time - this shouldn't happen
+            // for properly tracked arrays, but fall back to error
+            throw new Error(
+              `${line}:0 Error: Cannot determine buffer size for '${name}' at compile time.`,
+            );
           }
-          return `if (${offset} + ${length} <= sizeof(${name})) { memcpy(&${name}[${offset}], &${value}, ${length}); }`;
+
+          // Issue #234: Compile-time bounds validation
+          if (offsetValue + lengthValue > capacity) {
+            throw new Error(
+              `${line}:0 Error: Slice assignment out of bounds: ` +
+                `offset(${offsetValue}) + length(${lengthValue}) = ${offsetValue + lengthValue} ` +
+                `exceeds buffer capacity(${capacity}) for '${name}'.`,
+            );
+          }
+
+          if (offsetValue < 0) {
+            throw new Error(
+              `${line}:0 Error: Slice assignment offset cannot be negative: ${offsetValue}`,
+            );
+          }
+
+          if (lengthValue <= 0) {
+            throw new Error(
+              `${line}:0 Error: Slice assignment length must be positive: ${lengthValue}`,
+            );
+          }
+
+          // Set flag to include string.h for memcpy
+          this.needsString = true;
+
+          // Generate memcpy without runtime bounds check (already validated at compile time)
+          return `memcpy(&${name}[${offsetValue}], &${value}, ${lengthValue});`;
         }
 
         // Normal array element assignment (single index)

package/src/codegen/HeaderGenerator.ts

@@ -8,25 +8,13 @@ import ESymbolKind from "../types/ESymbolKind";
 import ESourceLanguage from "../types/ESourceLanguage";
 import SymbolTable from "../symbols/SymbolTable";
 import IHeaderOptions from "./types/IHeaderOptions";
+import IHeaderTypeInput from "./headerGenerators/IHeaderTypeInput";
+import typeUtils from "./headerGenerators/mapType";
+import generateEnumHeader from "./headerGenerators/generateEnumHeader";
+import generateStructHeader from "./headerGenerators/generateStructHeader";
+import generateBitmapHeader from "./headerGenerators/generateBitmapHeader";
 
-/**
- * Maps C-Next types to C types
- */
-const TYPE_MAP: Record<string, string> = {
-  u8: "uint8_t",
-  u16: "uint16_t",
-  u32: "uint32_t",
-  u64: "uint64_t",
-  i8: "int8_t",
-  i16: "int16_t",
-  i32: "int32_t",
-  i64: "int64_t",
-  f32: "float",
-  f64: "double",
-  bool: "bool",
-  void: "void",
-  ISR: "ISR", // ADR-040: Interrupt Service Routine function pointer
-};
+const { TYPE_MAP, mapType } = typeUtils;
 
 /**
  * Generates C header files from symbol information
@@ -34,11 +22,17 @@ const TYPE_MAP: Record<string, string> = {
 class HeaderGenerator {
   /**
    * Generate a header file from symbols
+   *
+   * @param symbols - Array of symbols to include in header
+   * @param filename - Output filename (used for include guard)
+   * @param options - Header generation options
+   * @param typeInput - Optional type information for full definitions (enums, structs, bitmaps)
    */
   generate(
     symbols: ISymbol[],
     filename: string,
     options: IHeaderOptions = {},
+    typeInput?: IHeaderTypeInput,
   ): string {
     const lines: string[] = [];
     const guard = this.makeGuard(filename, options.guardPrefix);
@@ -86,17 +80,22 @@ class HeaderGenerator {
     );
     const enums = exportedSymbols.filter((s) => s.kind === ESymbolKind.Enum);
     const types = exportedSymbols.filter((s) => s.kind === ESymbolKind.Type);
+    const bitmaps = exportedSymbols.filter(
+      (s) => s.kind === ESymbolKind.Bitmap,
+    );
 
     // Issue #121: Collect external type dependencies from function signatures
     const localStructNames = new Set(structs.map((s) => s.name));
     const localEnumNames = new Set(enums.map((s) => s.name));
     const localTypeNames = new Set(types.map((s) => s.name));
+    const localBitmapNames = new Set(bitmaps.map((s) => s.name));
     const externalTypes = this.collectExternalTypes(
       functions,
       variables,
       localStructNames,
       localEnumNames,
       localTypeNames,
+      localBitmapNames,
     );
 
     // Emit forward declarations for external types
@@ -110,25 +109,52 @@ class HeaderGenerator {
       lines.push("");
     }
 
-    // Forward declarations for structs
+    // Struct definitions or forward declarations
     if (structs.length > 0 || classes.length > 0) {
-      lines.push("/* Forward declarations */");
-      for (const sym of structs) {
-        lines.push(`typedef struct ${sym.name} ${sym.name};`);
-      }
-      for (const sym of classes) {
-        // Classes become typedefs to structs
-        lines.push(`typedef struct ${sym.name} ${sym.name};`);
+      if (typeInput) {
+        lines.push("/* Struct definitions */");
+        for (const sym of structs) {
+          lines.push(generateStructHeader(sym.name, typeInput));
+        }
+        for (const sym of classes) {
+          lines.push(generateStructHeader(sym.name, typeInput));
+        }
+      } else {
+        lines.push("/* Forward declarations */");
+        for (const sym of structs) {
+          lines.push(`typedef struct ${sym.name} ${sym.name};`);
+        }
+        for (const sym of classes) {
+          lines.push(`typedef struct ${sym.name} ${sym.name};`);
+        }
       }
       lines.push("");
     }
 
-    // Enum declarations
+    // Enum definitions or comments
     if (enums.length > 0) {
       lines.push("/* Enumerations */");
       for (const sym of enums) {
-        // For now, just forward declare - full definition would require enum values
-        lines.push(`/* Enum: ${sym.name} (see implementation for values) */`);
+        if (typeInput) {
+          lines.push(generateEnumHeader(sym.name, typeInput));
+        } else {
+          lines.push(`/* Enum: ${sym.name} (see implementation for values) */`);
+        }
+      }
+      lines.push("");
+    }
+
+    // Bitmap definitions (only when typeInput is available)
+    if (bitmaps.length > 0) {
+      lines.push("/* Bitmaps */");
+      for (const sym of bitmaps) {
+        if (typeInput) {
+          lines.push(generateBitmapHeader(sym.name, typeInput));
+        } else {
+          lines.push(
+            `/* Bitmap: ${sym.name} (see implementation for layout) */`,
+          );
+        }
       }
       lines.push("");
     }
@@ -138,7 +164,7 @@ class HeaderGenerator {
       lines.push("/* Type aliases */");
       for (const sym of types) {
         if (sym.type) {
-          const cType = this.mapType(sym.type);
+          const cType = mapType(sym.type);
           lines.push(`typedef ${cType} ${sym.name};`);
         }
       }
@@ -149,7 +175,7 @@ class HeaderGenerator {
     if (variables.length > 0) {
       lines.push("/* External variables */");
       for (const sym of variables) {
-        const cType = sym.type ? this.mapType(sym.type) : "int";
+        const cType = sym.type ? mapType(sym.type) : "int";
         lines.push(`extern ${cType} ${sym.name};`);
       }
       lines.push("");
@@ -224,47 +250,20 @@ class HeaderGenerator {
     return `${sanitized}_H`;
   }
 
-  /**
-   * Map a C-Next type to C type
-   */
-  private mapType(type: string): string {
-    // Check direct mapping first
-    if (TYPE_MAP[type]) {
-      return TYPE_MAP[type];
-    }
-
-    // Handle pointer types
-    if (type.endsWith("*")) {
-      const baseType = type.slice(0, -1).trim();
-      return `${this.mapType(baseType)}*`;
-    }
-
-    // Handle array types (simplified)
-    const arrayMatch = type.match(/^(\w+)\[(\d*)\]$/);
-    if (arrayMatch) {
-      const baseType = this.mapType(arrayMatch[1]);
-      const size = arrayMatch[2] || "";
-      return `${baseType}[${size}]`;
-    }
-
-    // User-defined types pass through
-    return type;
-  }
-
   /**
    * Generate a function prototype from symbol info
    * Handles all parameter edge cases per ADR-006, ADR-029, and ADR-040
    */
   private generateFunctionPrototype(sym: ISymbol): string | null {
     // Map return type from C-Next to C
-    const returnType = sym.type ? this.mapType(sym.type) : "void";
+    const returnType = sym.type ? mapType(sym.type) : "void";
 
     // Build parameter list with proper C semantics
     let params = "void"; // Default for no parameters
 
     if (sym.parameters && sym.parameters.length > 0) {
       const translatedParams = sym.parameters.map((p) => {
-        const baseType = this.mapType(p.type);
+        const baseType = mapType(p.type);
         const constMod = p.isConst ? "const " : "";
 
         // Handle array parameters (pass naturally as pointers per C semantics)
@@ -301,7 +300,7 @@ class HeaderGenerator {
    * Issue #121: Collect external type dependencies from function signatures and variables
    * Returns types that are:
    * - Not primitive types (not in TYPE_MAP)
-   * - Not locally defined structs, enums, or type aliases
+   * - Not locally defined structs, enums, bitmaps, or type aliases
    */
   private collectExternalTypes(
     functions: ISymbol[],
@@ -309,6 +308,7 @@ class HeaderGenerator {
     localStructs: Set<string>,
     localEnums: Set<string>,
     localTypes: Set<string>,
+    localBitmaps: Set<string>,
   ): Set<string> {
     const externalTypes = new Set<string>();
 
@@ -328,6 +328,9 @@ class HeaderGenerator {
       if (localTypes.has(typeName)) {
         return false;
       }
+      if (localBitmaps.has(typeName)) {
+        return false;
+      }
 
       // Skip pointer markers and array brackets
       if (typeName === "" || typeName === "*") {