c-next 0.1.8 → 0.1.9

package/README.md

@@ -773,6 +773,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.9",
   "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 test"
   },
   "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/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 === "*") {

package/src/codegen/generators/GeneratorRegistry.ts

@@ -62,8 +62,11 @@ export default class GeneratorRegistry {
    * @param kind - Declaration kind (e.g., 'struct', 'enum', 'function')
    * @param fn - Generator function
    */
-  registerDeclaration(kind: string, fn: TGeneratorFn<ParserRuleContext>): void {
-    this.declarations.set(kind, fn);
+  registerDeclaration<T extends ParserRuleContext>(
+    kind: string,
+    fn: TGeneratorFn<T>,
+  ): void {
+    this.declarations.set(kind, fn as TGeneratorFn<ParserRuleContext>);
   }
 
   /**
@@ -71,8 +74,11 @@ export default class GeneratorRegistry {
    * @param kind - Statement kind (e.g., 'if', 'while', 'assignment')
    * @param fn - Generator function
    */
-  registerStatement(kind: string, fn: TGeneratorFn<ParserRuleContext>): void {
-    this.statements.set(kind, fn);
+  registerStatement<T extends ParserRuleContext>(
+    kind: string,
+    fn: TGeneratorFn<T>,
+  ): void {
+    this.statements.set(kind, fn as TGeneratorFn<ParserRuleContext>);
   }
 
   /**
@@ -80,8 +86,11 @@ export default class GeneratorRegistry {
    * @param kind - Expression kind (e.g., 'ternary', 'binary', 'call')
    * @param fn - Generator function
    */
-  registerExpression(kind: string, fn: TGeneratorFn<ParserRuleContext>): void {
-    this.expressions.set(kind, fn);
+  registerExpression<T extends ParserRuleContext>(
+    kind: string,
+    fn: TGeneratorFn<T>,
+  ): void {
+    this.expressions.set(kind, fn as TGeneratorFn<ParserRuleContext>);
   }
 
   // =========================================================================

package/src/codegen/generators/declarationGenerators/ScopeGenerator.ts

@@ -268,7 +268,7 @@ function generateScopedBitmapInline(
     lines.push(" */");
   } else {
     // Fall back to AST parsing
-    const fields = node.bitmapField();
+    const fields = node.bitmapMember();
     if (fields.length > 0) {
       lines.push("/* Fields:");
       let bitOffset = 0;

package/src/codegen/generators/expressions/CallExprGenerator.ts

@@ -7,7 +7,10 @@
  * - C function calls with pass-by-value semantics
  * - Const-to-non-const validation (ADR-013)
  */
-import { ArgumentListContext } from "../../../parser/grammar/CNextParser";
+import {
+  ArgumentListContext,
+  ExpressionContext,
+} from "../../../parser/grammar/CNextParser";
 import IGeneratorOutput from "../IGeneratorOutput";
 import TGeneratorEffect from "../TGeneratorEffect";
 import IGeneratorInput from "../IGeneratorInput";
@@ -94,7 +97,7 @@ const generateFunctionCall = (
  */
 const generateSafeDivMod = (
   funcName: string,
-  argExprs: ReturnType<ArgumentListContext["expression"]>,
+  argExprs: ExpressionContext[],
   input: IGeneratorInput,
   orchestrator: IOrchestrator,
   effects: TGeneratorEffect[],
@@ -157,7 +160,7 @@ const generateSafeDivMod = (
  */
 const validateConstToNonConst = (
   funcName: string,
-  argExprs: ReturnType<ArgumentListContext["expression"]>,
+  argExprs: ExpressionContext[],
   input: IGeneratorInput,
   orchestrator: IOrchestrator,
 ): void => {

package/src/codegen/headerGenerators/IHeaderTypeInput.ts

@@ -0,0 +1,32 @@
+/**
+ * Input interface for header type generators.
+ * Provides read-only access to symbol data needed for generating
+ * type definitions in C headers.
+ *
+ * This interface is a subset of ISymbolInfo, containing only
+ * the data needed for generating enums, structs, and bitmaps.
+ */
+interface IHeaderTypeInput {
+  /** Enum members and values: enumName -> (memberName -> value) */
+  readonly enumMembers: ReadonlyMap<string, ReadonlyMap<string, number>>;
+
+  /** Struct field types: structName -> (fieldName -> typeName) */
+  readonly structFields: ReadonlyMap<string, ReadonlyMap<string, string>>;
+
+  /** Array dimensions for struct fields: structName -> (fieldName -> dimensions) */
+  readonly structFieldDimensions: ReadonlyMap<
+    string,
+    ReadonlyMap<string, readonly number[]>
+  >;
+
+  /** Backing type for each bitmap: bitmapName -> typeName (e.g., "uint8_t") */
+  readonly bitmapBackingType: ReadonlyMap<string, string>;
+
+  /** Bitmap field info: bitmapName -> (fieldName -> {offset, width}) */
+  readonly bitmapFields: ReadonlyMap<
+    string,
+    ReadonlyMap<string, { readonly offset: number; readonly width: number }>
+  >;
+}
+
+export default IHeaderTypeInput;