c-next 0.1.65 → 0.1.67

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -5,7 +5,7 @@
 
 import { CommonTokenStream, ParserRuleContext } from "antlr4ng";
 import * as Parser from "../../logic/parser/grammar/CNextParser";
-import SymbolTable from "../../logic/symbols/SymbolTable";
+
 import ESymbolKind from "../../../utils/types/ESymbolKind";
 import CommentExtractor from "../../logic/analysis/CommentExtractor";
 import CommentFormatter from "./CommentFormatter";
@@ -67,7 +67,7 @@ import memberAccessChain from "./memberAccessChain";
 import AssignmentHandlerRegistry from "./assignment/index";
 import AssignmentClassifier from "./assignment/AssignmentClassifier";
 import buildAssignmentContext from "./assignment/AssignmentContextBuilder";
-import IHandlerDeps from "./assignment/handlers/IHandlerDeps";
+// IHandlerDeps removed - handlers now use CodeGenState.generator directly
 // Issue #461: LiteralUtils for parsing const values from symbol table
 import LiteralUtils from "../../../utils/LiteralUtils";
 // Issue #644: Extracted string length counter for strlen caching optimization
@@ -133,7 +133,10 @@ import TypeGenerationHelper from "./helpers/TypeGenerationHelper";
 // Phase 5: Cast validation helper for improved testability
 import CastValidator from "./helpers/CastValidator";
 // Global state for code generation (simplifies debugging, eliminates DI complexity)
-import CodeGenState from "./CodeGenState";
+import CodeGenState from "../../state/CodeGenState";
+// Unified parameter generation (Phase 1)
+import ParameterInputAdapter from "./helpers/ParameterInputAdapter";
+import ParameterSignatureBuilder from "./helpers/ParameterSignatureBuilder";
 // Extracted resolvers that use CodeGenState
 import SizeofResolver from "./resolution/SizeofResolver";
 import EnumTypeResolver from "./resolution/EnumTypeResolver";
@@ -676,7 +679,7 @@ export default class CodeGenerator implements IOrchestrator {
       currentScope: CodeGenState.currentScope,
       isCppScopeSymbol: (name) => this.isCppScopeSymbol(name),
       checkNeedsStructKeyword: (name) =>
-        CodeGenState.symbolTable?.checkNeedsStructKeyword(name) ?? false,
+        CodeGenState.symbolTable.checkNeedsStructKeyword(name),
       validateCrossScopeVisibility: (scope, member) =>
         ScopeResolver.validateCrossScopeVisibility(scope, member),
     });
@@ -802,30 +805,54 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Issue #137: Check for array element access (e.g., names[0], arr[i])
+    return this._isArrayAccessStringExpression(text);
+  }
+
+  /**
+   * Check if array access expression evaluates to a string.
+   * Extracted from isStringExpression to reduce cognitive complexity.
+   */
+  private _isArrayAccessStringExpression(text: string): boolean {
     // Pattern: identifier[expression] or identifier[expression][expression]...
     // BUT NOT if accessing .length/.capacity/.size (those return numbers, not strings)
     const arrayAccessMatch = /^([a-zA-Z_]\w*)\[/.exec(text);
-    if (arrayAccessMatch) {
-      // ADR-045: String properties return numeric values, not strings
-      if (
-        text.endsWith(".length") ||
-        text.endsWith(".capacity") ||
-        text.endsWith(".size")
-      ) {
-        return false;
-      }
-      const arrayName = arrayAccessMatch[1];
-      const typeInfo = CodeGenState.typeRegistry.get(arrayName);
-      // Check if base type is a string type
-      if (
-        typeInfo?.isString ||
-        (typeInfo?.baseType && TypeCheckUtils.isString(typeInfo.baseType))
-      ) {
-        return true;
-      }
+    if (!arrayAccessMatch) {
+      return false;
     }
 
-    return false;
+    // ADR-045: String properties return numeric values, not strings
+    if (
+      text.endsWith(".length") ||
+      text.endsWith(".capacity") ||
+      text.endsWith(".size")
+    ) {
+      return false;
+    }
+
+    const arrayName = arrayAccessMatch[1];
+    const typeInfo = CodeGenState.typeRegistry.get(arrayName);
+    if (!typeInfo) {
+      return false;
+    }
+
+    // Check if it's an ARRAY OF STRINGS (not a single string being indexed)
+    // A single string<50> has arrayDimensions=[51] (just the char buffer)
+    // An array of strings string<50>[10] has arrayDimensions=[10, 51]
+    // Single string indexing (e.g., userName[i]) returns a char, not a string
+    // Array of strings indexing (e.g., names[0]) returns a string
+    if (typeInfo.isString) {
+      // For strings, only treat as string expression if it's an array of strings
+      // (arrayDimensions.length > 1 means it's string<N>[M], not just string<N>)
+      const dims = typeInfo.arrayDimensions;
+      return Array.isArray(dims) && dims.length > 1;
+    }
+
+    // Non-string array with string base type
+    return Boolean(
+      typeInfo.isArray &&
+      typeInfo.baseType &&
+      TypeCheckUtils.isString(typeInfo.baseType),
+    );
   }
 
   /**
@@ -1505,7 +1532,9 @@ export default class CodeGenerator implements IOrchestrator {
                 return `${constMod}${p.type} ${p.name}${p.arrayDims}`;
               } else if (p.isPointer) {
                 // ADR-006: Non-array, non-callback parameters become pointers
-                return `${constMod}${p.type}*`;
+                // In C++ mode, use reference (&) instead of pointer (*)
+                const ptrOrRef = this.isCppMode() ? "&" : "*";
+                return `${constMod}${p.type}${ptrOrRef}`;
               } else {
                 // ADR-029: Callback parameters are already function pointers
                 return `${p.type}`;
@@ -2088,13 +2117,11 @@ export default class CodeGenerator implements IOrchestrator {
   /**
    * Generate C code from a C-Next program
    * @param tree The parsed C-Next program
-   * @param symbolTable Optional symbol table for cross-language interop
    * @param tokenStream Optional token stream for comment preservation (ADR-043)
    * @param options Optional code generator options (e.g., debugMode)
    */
   generate(
     tree: Parser.ProgramContext,
-    symbolTable?: SymbolTable,
     tokenStream?: CommonTokenStream,
     options?: ICodeGeneratorOptions,
   ): string {
@@ -2116,9 +2143,6 @@ export default class CodeGenerator implements IOrchestrator {
     // Initialize options and configuration (after reset)
     this.initializeGenerateOptions(options, tokenStream);
 
-    // Store symbol table for function lookup (after reset)
-    CodeGenState.symbolTable = symbolTable ?? null;
-
     // ADR-055: Use pre-collected symbolInfo from Pipeline (TSymbolInfoAdapter)
     if (!options?.symbolInfo) {
       throw new Error(
@@ -2169,6 +2193,9 @@ export default class CodeGenerator implements IOrchestrator {
     // Reset global state first
     CodeGenState.reset(targetCapabilities);
 
+    // Set generator reference for handlers to use
+    CodeGenState.generator = this;
+
     // Reset local context (will gradually migrate to CodeGenState)
     this.context = CodeGenerator.createDefaultContext(targetCapabilities);
 
@@ -2373,9 +2400,13 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private addGeneratedHelpers(output: string[]): void {
     if (CodeGenState.needsFloatStaticAssert) {
+      // Use static_assert for C++ (standard), _Static_assert for C11
+      const assertKeyword = this.isCppMode()
+        ? "static_assert"
+        : "_Static_assert";
       output.push(
-        '_Static_assert(sizeof(float) == 4, "Float bit indexing requires 32-bit float");',
-        '_Static_assert(sizeof(double) == 8, "Float bit indexing requires 64-bit double");',
+        `${assertKeyword}(sizeof(float) == 4, "Float bit indexing requires 32-bit float");`,
+        `${assertKeyword}(sizeof(double) == 8, "Float bit indexing requires 64-bit double");`,
         "",
       );
     }
@@ -5273,16 +5304,47 @@ export default class CodeGenerator implements IOrchestrator {
   }
 
   private generateParameter(ctx: Parser.ParameterContext): string {
-    const constMod = ctx.constModifier() ? "const " : "";
     const typeName = this.getTypeName(ctx.type());
     const name = ctx.IDENTIFIER().getText();
-    const dims = ctx.arrayDimension();
 
-    // Reject ALL C-style array parameters - require C-Next style (dimensions in type)
-    // C-style: u8 data[8], u8 data[4][4], u8 data[]
-    // C-Next:  u8[8] data, u8[4][4] data, u8[] data
+    // Validate: Reject C-style array parameters
+    this._validateCStyleArrayParam(ctx, typeName, name);
+
+    // Validate: Reject unbounded array dimensions
+    this._validateUnboundedArrayParam(ctx);
+
+    // Pre-compute CodeGenState-dependent values
+    const isModified = this._isCurrentParameterModified(name);
+    const isPassByValue = this._isPassByValueType(typeName, name);
+
+    // Build normalized input using adapter
+    const input = ParameterInputAdapter.fromAST(ctx, {
+      getTypeName: (t) => this.getTypeName(t),
+      generateType: (t) => this.generateType(t),
+      generateExpression: (e) => this.generateExpression(e),
+      callbackTypes: CodeGenState.callbackTypes,
+      isKnownStruct: (t) => this.isKnownStruct(t),
+      typeMap: TYPE_MAP,
+      isModified,
+      isPassByValue,
+    });
+
+    // Use shared builder with C/C++ mode
+    return ParameterSignatureBuilder.build(input, CppModeHelper.refOrPtr());
+  }
+
+  /**
+   * Validate: Reject C-style array parameters
+   * C-style: u8 data[8], u8 data[4][4], u8 data[]
+   * C-Next:  u8[8] data, u8[4][4] data, u8[] data
+   */
+  private _validateCStyleArrayParam(
+    ctx: Parser.ParameterContext,
+    typeName: string,
+    name: string,
+  ): void {
+    const dims = ctx.arrayDimension();
     if (dims.length > 0) {
-      const baseType = typeName;
       const dimensions = dims
         .map((dim) => `[${dim.expression()?.getText() ?? ""}]`)
         .join("");
@@ -5290,73 +5352,28 @@ export default class CodeGenerator implements IOrchestrator {
       const col = ctx.start?.column ?? 0;
       throw new Error(
         `${line}:${col} C-style array parameter is not allowed. ` +
-          `Use '${baseType}${dimensions} ${name}' instead of '${baseType} ${name}${dimensions}'`,
+          `Use '${typeName}${dimensions} ${name}' instead of '${typeName} ${name}${dimensions}'`,
       );
     }
+  }
 
-    // ADR-029: Check if this is a callback type parameter
-    if (CodeGenState.callbackTypes.has(typeName)) {
-      const callbackInfo = CodeGenState.callbackTypes.get(typeName)!;
-      return `${callbackInfo.typedefName} ${name}`;
-    }
-
-    const type = this.generateType(ctx.type());
-
-    // Handle C-Next style array type in parameter (e.g., u8[8] param, u8[4][4] param, string<32>[5] param)
+  /**
+   * Validate: Reject unbounded array dimensions for memory safety
+   */
+  private _validateUnboundedArrayParam(ctx: Parser.ParameterContext): void {
     const arrayTypeCtx = ctx.type().arrayType();
-    if (arrayTypeCtx) {
-      // Check for unbounded dimensions - reject for memory safety
-      const allDims = arrayTypeCtx.arrayTypeDimension();
-      const hasUnboundedDim = allDims.some((d) => !d.expression());
-      if (hasUnboundedDim) {
-        const line = ctx.start?.line ?? 0;
-        const col = ctx.start?.column ?? 0;
-        throw new Error(
-          `${line}:${col} Unbounded array parameters are not allowed. ` +
-            `All dimensions must have explicit sizes for memory safety.`,
-        );
-      }
+    if (!arrayTypeCtx) return;
 
-      let dims = allDims
-        .map((d) => {
-          const expr = d.expression();
-          return expr ? `[${this.generateExpression(expr)}]` : "[]";
-        })
-        .join("");
-      // For string arrays, add the string capacity dimension (string<32>[5] -> char[5][33])
-      if (arrayTypeCtx.stringType()) {
-        const stringCtx = arrayTypeCtx.stringType()!;
-        const intLiteral = stringCtx.INTEGER_LITERAL();
-        if (intLiteral) {
-          const capacity = Number.parseInt(intLiteral.getText(), 10);
-          dims += `[${capacity + 1}]`;
-        }
-      }
-      const wasModified = this._isCurrentParameterModified(name);
-      const autoConst = !wasModified && !constMod ? "const " : "";
-      return `${autoConst}${constMod}${type} ${name}${dims}`;
-    }
-
-    // Pass-by-value types
-    if (this._isPassByValueType(typeName, name)) {
-      return `${constMod}${type} ${name}`;
+    const allDims = arrayTypeCtx.arrayTypeDimension();
+    const hasUnboundedDim = allDims.some((d) => !d.expression());
+    if (hasUnboundedDim) {
+      const line = ctx.start?.line ?? 0;
+      const col = ctx.start?.column ?? 0;
+      throw new Error(
+        `${line}:${col} Unbounded array parameters are not allowed. ` +
+          `All dimensions must have explicit sizes for memory safety.`,
+      );
     }
-
-    // Non-array string parameters
-    const stringResult = this._tryGenerateStringParam(
-      ctx,
-      constMod,
-      name,
-      dims,
-    );
-    if (stringResult) return stringResult;
-
-    // Pass-by-reference types
-    const refResult = this._tryGenerateRefParam(constMod, type, typeName, name);
-    if (refResult) return refResult;
-
-    // Unknown types use pass-by-value (standard C semantics)
-    return `${constMod}${type} ${name}`;
   }
 
   /**
@@ -5366,7 +5383,7 @@ export default class CodeGenerator implements IOrchestrator {
     // ISR, float, enum types
     if (typeName === "ISR") return true;
     if (this._isFloatType(typeName)) return true;
-    if (CodeGenState.symbols!.knownEnums.has(typeName)) return true;
+    if (CodeGenState.symbols?.knownEnums.has(typeName)) return true;
 
     // Small unmodified primitives
     if (
@@ -5379,43 +5396,6 @@ export default class CodeGenerator implements IOrchestrator {
     return false;
   }
 
-  /**
-   * Try to generate non-array string parameter: string<N> -> char*
-   */
-  private _tryGenerateStringParam(
-    ctx: Parser.ParameterContext,
-    constMod: string,
-    name: string,
-    dims: Parser.ArrayDimensionContext[],
-  ): string | null {
-    if (!ctx.type().stringType() || dims.length !== 0) {
-      return null;
-    }
-
-    const wasModified = this._isCurrentParameterModified(name);
-    const autoConst = !wasModified && !constMod ? "const " : "";
-    return `${autoConst}${constMod}char* ${name}`;
-  }
-
-  /**
-   * Try to generate pass-by-reference parameter for known types
-   */
-  private _tryGenerateRefParam(
-    constMod: string,
-    type: string,
-    typeName: string,
-    name: string,
-  ): string | null {
-    if (!this.isKnownStruct(typeName) && !this._isKnownPrimitive(typeName)) {
-      return null;
-    }
-
-    const wasModified = this._isCurrentParameterModified(name);
-    const autoConst = !wasModified && !constMod ? "const " : "";
-    const refOrPtr = CppModeHelper.refOrPtr();
-    return `${autoConst}${constMod}${type}${refOrPtr} ${name}`;
-  }
-
   // ========================================================================
   // Variables
   // ========================================================================
@@ -6044,54 +6024,14 @@ export default class CodeGenerator implements IOrchestrator {
   // Issue #644: _generateBitMask removed, now delegating to BitUtils.generateMask
   // ========================================================================
 
-  // ADR-109: Build handler dependencies for assignment dispatch
-  private buildHandlerDeps(): IHandlerDeps {
-    return {
-      symbols: CodeGenState.symbols!,
-      typeRegistry: CodeGenState.typeRegistry,
-      currentScope: CodeGenState.currentScope,
-      currentParameters: CodeGenState.currentParameters,
-      targetCapabilities: CodeGenState.targetCapabilities,
-      generateExpression: (ctx) => this.generateExpression(ctx),
-      tryEvaluateConstant: (ctx) => this.tryEvaluateConstant(ctx),
-      generateAssignmentTarget: (ctx) => this.generateAssignmentTarget(ctx),
-      isKnownStruct: (name) => this.isKnownStruct(name),
-      isKnownScope: (name) => this.isKnownScope(name),
-      getMemberTypeInfo: (structType, memberName) =>
-        this.getMemberTypeInfo(structType, memberName),
-      validateBitmapFieldLiteral: (expr, width, fieldName) =>
-        TypeValidator.validateBitmapFieldLiteral(expr, width, fieldName),
-      validateCrossScopeVisibility: (scopeName, memberName) =>
-        this.validateCrossScopeVisibility(scopeName, memberName),
-      checkArrayBounds: (arrayName, dimensions, indexExprs, line) =>
-        TypeValidator.checkArrayBounds(
-          arrayName,
-          [...dimensions],
-          [...indexExprs],
-          line,
-          (expr) => this.tryEvaluateConstant(expr),
-        ),
-      analyzeMemberChainForBitAccess: (targetCtx) =>
-        this.analyzeMemberChainForBitAccess(targetCtx),
-      generateFloatBitWrite: (name, typeInfo, bitIndex, width, value) =>
-        this.generateFloatBitWrite(name, typeInfo, bitIndex, width, value),
-      foldBooleanToInt: (expr) => this.foldBooleanToInt(expr),
-      markNeedsString: () => {
-        this.requireInclude("string");
-      },
-      markClampOpUsed: (op, typeName) => this.markClampOpUsed(op, typeName),
-      generateAtomicRMW: (target, cOp, value, typeInfo) =>
-        this.generateAtomicRMW(target, cOp, value, typeInfo),
-    };
-  }
+  // ADR-109: buildHandlerDeps removed - handlers now use CodeGenState.generator directly
 
   /**
    * Analyze a member chain target to detect bit access at the end.
    * Issue #644: Delegates to MemberChainAnalyzer.
    */
-  private analyzeMemberChainForBitAccess(
-    targetCtx: Parser.AssignmentTargetContext,
-  ): {
+  /** Public for handler access via CodeGenState.generator */
+  analyzeMemberChainForBitAccess(targetCtx: Parser.AssignmentTargetContext): {
     isBitAccess: boolean;
     baseTarget?: string;
     bitIndex?: string;
@@ -6107,7 +6047,8 @@ export default class CodeGenerator implements IOrchestrator {
    * Generate float bit write using shadow variable + memcpy.
    * Issue #644: Delegates to FloatBitHelper.
    */
-  private generateFloatBitWrite(
+  /** Public for handler access via CodeGenState.generator */
+  generateFloatBitWrite(
     name: string,
     typeInfo: TTypeInfo,
     bitIndex: string,
@@ -6180,17 +6121,18 @@ export default class CodeGenerator implements IOrchestrator {
       typeRegistry: CodeGenState.typeRegistry,
       generateExpression: () => value,
     });
-    const handlerDeps = this.buildHandlerDeps();
+    // ADR-109: Handlers access CodeGenState directly, no deps needed
     const assignmentKind = AssignmentClassifier.classify(assignCtx);
     const handler = AssignmentHandlerRegistry.getHandler(assignmentKind);
-    return handler(assignCtx, handlerDeps);
+    return handler(assignCtx);
   }
 
   /**
    * ADR-049: Generate atomic Read-Modify-Write operation
    * Uses LDREX/STREX on platforms that support it, otherwise PRIMASK
    */
-  private generateAtomicRMW(
+  /** Public for handler access via CodeGenState.generator */
+  generateAtomicRMW(
     target: string,
     cOp: string,
     value: string,
@@ -6440,7 +6382,7 @@ export default class CodeGenerator implements IOrchestrator {
       return null;
     }
 
-    // No expected enum type - search all enums but error on ambiguity
+    // No expected enum type - bare enum members are not allowed without context
     const matchingEnums: string[] = [];
     for (const [enumName, members] of CodeGenState.symbols!.enumMembers) {
       if (members.has(id)) {
@@ -6449,11 +6391,14 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     if (matchingEnums.length === 1) {
-      return `${matchingEnums[0]}${this.getScopeSeparator(false)}${id}`;
+      throw new Error(
+        `error[E0424]: '${id}' is not defined; did you mean '${matchingEnums[0]}.${id}'?`,
+      );
     }
     if (matchingEnums.length > 1) {
+      const suggestions = matchingEnums.map((e) => `'${e}.${id}'`).join(" or ");
       throw new Error(
-        `Error: Ambiguous enum member '${id}' exists in multiple enums: ${matchingEnums.join(", ")}. Use qualified access (e.g., ${matchingEnums[0]}.${id})`,
+        `error[E0424]: '${id}' is not defined; did you mean ${suggestions}?`,
       );
     }
 

package/src/transpiler/output/codegen/TypeResolver.ts

@@ -3,7 +3,7 @@
  * Static class that reads from CodeGenState directly.
  */
 import * as Parser from "../../logic/parser/grammar/CNextParser";
-import CodeGenState from "./CodeGenState";
+import CodeGenState from "../../state/CodeGenState";
 import INTEGER_TYPES from "./types/INTEGER_TYPES";
 import FLOAT_TYPES from "./types/FLOAT_TYPES";
 import SIGNED_TYPES from "./types/SIGNED_TYPES";
@@ -73,7 +73,7 @@ class TypeResolver {
     if (CodeGenState.symbols?.knownBitmaps.has(typeName)) {
       return true;
     }
-    if (CodeGenState.symbolTable?.getStructFields(typeName)) {
+    if (CodeGenState.symbolTable.getStructFields(typeName)) {
       return true;
     }
     return false;

package/src/transpiler/output/codegen/TypeValidator.ts

@@ -6,7 +6,7 @@
 import { existsSync } from "node:fs";
 import { dirname, resolve, join } from "node:path";
 import * as Parser from "../../logic/parser/grammar/CNextParser";
-import CodeGenState from "./CodeGenState";
+import CodeGenState from "../../state/CodeGenState";
 import TypeResolver from "./TypeResolver";
 import ExpressionUtils from "../../../utils/ExpressionUtils";
 // SonarCloud S3776: Extracted literal parsing to reduce complexity