c-next 0.1.29 → 0.1.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {

package/src/codegen/CodeGenerator.ts

@@ -319,6 +319,13 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private functionParamLists: Map<string, string[]> = new Map();
 
+  /**
+   * Issue #369: Tracks whether self-include was added.
+   * When true, skip struct/enum/bitmap definitions in .c file because
+   * they'll be defined in the included header.
+   */
+  private selfIncludeAdded: boolean = false;
+
   /**
    * Initialize generator registry with extracted generators.
    * Called once before code generation begins.
@@ -380,6 +387,7 @@ export default class CodeGenerator implements IOrchestrator {
       localVariables: this.context.localVariables,
       localArrays: this.context.localArrays,
       expectedType: this.context.expectedType,
+      selfIncludeAdded: this.selfIncludeAdded, // Issue #369
     };
   }
 
@@ -1383,6 +1391,7 @@ export default class CodeGenerator implements IOrchestrator {
     this.needsString = false; // ADR-045: Reset string header tracking
     this.needsISR = false; // ADR-040: Reset ISR typedef tracking
     this.needsCMSIS = false; // ADR-049/050: Reset CMSIS include tracking
+    this.selfIncludeAdded = false; // Issue #369: Reset self-include tracking
 
     // First pass: collect namespace and class members
     // Issue #60: Create SymbolCollector (extracted from CodeGenerator)
@@ -1443,6 +1452,7 @@ export default class CodeGenerator implements IOrchestrator {
     // When file has public symbols and headers are being generated,
     // include own header to ensure proper C linkage
     // Issue #339: Use relative path from source root when available
+    // Issue #369: Track self-include to skip type definitions in .c file
     if (
       options?.generateHeaders &&
       this.symbols!.hasPublicSymbols() &&
@@ -1455,6 +1465,8 @@ export default class CodeGenerator implements IOrchestrator {
       const headerName = pathToUse.replace(/\.cnx$|\.cnext$/, ".h");
       output.push(`#include "${headerName}"`);
       output.push("");
+      // Issue #369: Mark that self-include was added - types will be in header
+      this.selfIncludeAdded = true;
     }
 
     // Pass through #include directives from source
@@ -2136,16 +2148,62 @@ export default class CodeGenerator implements IOrchestrator {
       }
     }
 
-    // Check for scope-qualified calls: Scope.func(...)
-    // primaryExpression could be 'global' or 'this' with member access
-    // For now, handle the simple case where we see IDENTIFIER.IDENTIFIER(...)
+    // Issue #365: Handle scope-qualified calls: Scope.method(...) or global.Scope.method(...)
+    // Track member accesses to build the mangled callee name (e.g., Storage_load)
+    // Then when we find the function call, record it to the call graph
+    if (postfixOps.length > 0) {
+      const memberNames: string[] = [];
+
+      // Start with primary identifier if it's a scope name (not 'global' or 'this')
+      const primaryId = primary.IDENTIFIER()?.getText();
+      if (primaryId && primaryId !== "global" && primaryId !== "this") {
+        memberNames.push(primaryId);
+      }
+
+      // Collect member access names until we hit a function call
+      for (const op of postfixOps) {
+        if (op.IDENTIFIER()) {
+          // Member access: .IDENTIFIER
+          memberNames.push(op.IDENTIFIER()!.getText());
+        } else if (op.LPAREN()) {
+          // Function call found - record to call graph if we have a callee name
+          if (memberNames.length >= 1) {
+            // Build mangled name: e.g., ["Storage", "load"] -> "Storage_load"
+            // For scope methods, the last name is the method, everything before is scope
+            const calleeName = memberNames.join("_");
+            const argList = op.argumentList();
+
+            if (argList) {
+              const args = argList.expression();
+              for (let j = 0; j < args.length; j++) {
+                const arg = args[j];
+                const argName = this.getSimpleIdentifierFromExpr(arg);
+                if (argName && paramSet.has(argName)) {
+                  this.functionCallGraph.get(funcName)!.push({
+                    callee: calleeName,
+                    paramIndex: j,
+                    argParamName: argName,
+                  });
+                }
+              }
+            }
+          }
+          // Reset for potential chained calls like obj.foo().bar()
+          memberNames.length = 0;
+        } else if (op.expression().length > 0) {
+          // Array subscript - doesn't contribute to method name
+          // but reset member chain as array access breaks scope chain
+          memberNames.length = 0;
+        }
+      }
+    }
 
     // Recurse into primary expression if it's a parenthesized expression
     if (primary.expression()) {
       this.walkExpressionForCalls(funcName, paramSet, primary.expression()!);
     }
 
-    // Walk arguments in any postfix function call ops
+    // Walk arguments in any postfix function call ops (for nested calls)
     for (const op of postfixOps) {
       if (op.argumentList()) {
         for (const argExpr of op.argumentList()!.expression()) {
@@ -4372,15 +4430,26 @@ export default class CodeGenerator implements IOrchestrator {
     if (ctx.registerDeclaration()) {
       return this.generateRegister(ctx.registerDeclaration()!);
     }
+    // Issue #369: Skip struct/enum/bitmap definitions when self-include is added
+    // These types will be defined in the included header file
     if (ctx.structDeclaration()) {
+      if (this.selfIncludeAdded) {
+        return ""; // Definition will come from header
+      }
       return this.generateStruct(ctx.structDeclaration()!);
     }
     // ADR-017: Handle enum declarations
     if (ctx.enumDeclaration()) {
+      if (this.selfIncludeAdded) {
+        return ""; // Definition will come from header
+      }
       return this.generateEnum(ctx.enumDeclaration()!);
     }
     // ADR-034: Handle bitmap declarations
     if (ctx.bitmapDeclaration()) {
+      if (this.selfIncludeAdded) {
+        return ""; // Definition will come from header
+      }
       return this.generateBitmap(ctx.bitmapDeclaration()!);
     }
     if (ctx.functionDeclaration()) {
@@ -6859,14 +6928,22 @@ export default class CodeGenerator implements IOrchestrator {
       const exprs = arrayAccessCtx.expression();
       const typeInfo = this.context.typeRegistry.get(name);
 
+      // Issue #368: Check if this is an array parameter (e.g., void foo(u8 data[]))
+      // Array parameters may not have arrayDimensions in typeRegistry (for unsized params),
+      // but they ARE arrays and should use array indexing, not bit manipulation.
+      const paramInfo = this.context.currentParameters.get(name);
+      const isArrayParameter = paramInfo?.isArray ?? false;
+
       // ADR-040: ISR arrays use normal array indexing, not bit manipulation
       // Also handle any array type that isn't an integer scalar
       // Issue #213: String parameters (isString=true) should also use memcpy for slice assignment
+      // Issue #368: Array parameters (even unsized like u8 data[]) should use array indexing
       const isActualArray =
         (typeInfo?.isArray &&
           typeInfo.arrayDimensions &&
           typeInfo.arrayDimensions.length > 0) ||
-        typeInfo?.isString;
+        typeInfo?.isString ||
+        isArrayParameter;
       const isISRType = typeInfo?.baseType === "ISR";
 
       if (isActualArray || isISRType) {

package/src/codegen/TypeValidator.ts

@@ -866,16 +866,8 @@ class TypeValidator {
                   for (const add of shift.additiveExpression()) {
                     for (const mult of add.multiplicativeExpression()) {
                       for (const unary of mult.unaryExpression()) {
-                        const postfix = unary.postfixExpression();
-                        if (postfix) {
-                          for (const op of postfix.postfixOp()) {
-                            if (
-                              op.argumentList() ||
-                              op.getText().startsWith("(")
-                            ) {
-                              return true;
-                            }
-                          }
+                        if (this.hasPostfixFunctionCallInUnary(unary)) {
+                          return true;
                         }
                       }
                     }
@@ -890,6 +882,32 @@ class TypeValidator {
     return false;
   }
 
+  /**
+   * Issue #366: Recursively check unaryExpression for function calls.
+   * Handles unary operators (!, -, ~, &) that wrap function calls,
+   * including arbitrary nesting like !!isReady() or -~getValue().
+   */
+  private hasPostfixFunctionCallInUnary(
+    unary: Parser.UnaryExpressionContext,
+  ): boolean {
+    // Recurse through nested unary operators (!, -, ~, &) until we reach postfixExpression
+    const nestedUnary = unary.unaryExpression();
+    if (nestedUnary) {
+      return this.hasPostfixFunctionCallInUnary(nestedUnary);
+    }
+
+    // Base case: check postfixExpression
+    const postfix = unary.postfixExpression();
+    if (postfix) {
+      for (const op of postfix.postfixOp()) {
+        if (op.argumentList() || op.getText().startsWith("(")) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   // ========================================================================
   // Shift Amount Validation (MISRA C:2012 Rule 12.2)
   // ========================================================================

package/src/codegen/generators/IGeneratorState.ts

@@ -26,6 +26,13 @@ interface IGeneratorState {
 
   /** Expected type for inferred struct initializers */
   readonly expectedType: string | null;
+
+  /**
+   * Issue #369: Whether self-include was added.
+   * When true, type definitions (struct/enum/bitmap) should not be emitted
+   * in the .c file as they'll come from the included header.
+   */
+  readonly selfIncludeAdded: boolean;
 }
 
 export default IGeneratorState;

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

@@ -142,14 +142,16 @@ const generateScope: TGeneratorFn<Parser.ScopeDeclarationContext> = (
 
     // ADR-017: Handle enum declarations inside scopes
     // The enum generator will use state.currentScope which we've set via orchestrator
-    if (member.enumDeclaration()) {
+    // Issue #369: Skip enum definition if self-include was added (it will be in the header)
+    if (member.enumDeclaration() && !state.selfIncludeAdded) {
       const enumDecl = member.enumDeclaration()!;
       lines.push("");
       lines.push(generateScopedEnumInline(enumDecl, name, input, orchestrator));
     }
 
     // ADR-034: Handle bitmap declarations inside scopes
-    if (member.bitmapDeclaration()) {
+    // Issue #369: Skip bitmap definition if self-include was added (it will be in the header)
+    if (member.bitmapDeclaration() && !state.selfIncludeAdded) {
       const bitmapDecl = member.bitmapDeclaration()!;
       lines.push("");
       lines.push(generateScopedBitmapInline(bitmapDecl, name, input));