c-next 0.2.16 → 0.2.18

package/src/transpiler/output/headers/generators/generateStructHeader.ts

@@ -11,6 +11,52 @@ import CppNamespaceUtils from "../../../../utils/CppNamespaceUtils";
 
 const { mapType } = typeUtils;
 
+/**
+ * Resolve the C type for a struct field, checking for callback types first.
+ */
+function resolveFieldCType(fieldType: string, input: IHeaderTypeInput): string {
+  // ADR-029: Check if field type is a callback type and use typedef name
+  const callbackInfo = input.callbackTypes?.get(fieldType);
+  if (callbackInfo) {
+    return callbackInfo.typedefName;
+  }
+  // Issue #502/#522: Convert C++ namespace types from _ to :: format
+  const convertedType = CppNamespaceUtils.convertToCppNamespace(
+    fieldType,
+    input.symbolTable,
+  );
+  return mapType(convertedType);
+}
+
+/**
+ * Generate the field line for a struct member, handling embedded dimensions.
+ *
+ * Issue #461: Handle string<N> types which map to char[N+1]
+ * The embedded dimension must come after array dimensions in C syntax.
+ * Example: string<64> arr[4] -> char arr[4][65], not char[65] arr[4]
+ */
+function generateFieldLine(
+  fieldName: string,
+  cType: string,
+  dims: readonly number[] | undefined,
+): string {
+  const dimSuffix =
+    dims && dims.length > 0 ? dims.map((d) => `[${d}]`).join("") : "";
+  const embeddedMatch = /^(\w+)\[(\d+)\]$/.exec(cType);
+
+  if (!embeddedMatch) {
+    return `    ${cType} ${fieldName}${dimSuffix};`;
+  }
+
+  const baseType = embeddedMatch[1];
+  const embeddedDim = embeddedMatch[2];
+  // When dims are provided, they already include string capacity from StructCollector
+  if (dims && dims.length > 0) {
+    return `    ${baseType} ${fieldName}${dimSuffix};`;
+  }
+  return `    ${baseType} ${fieldName}[${embeddedDim}];`;
+}
+
 /**
  * Generate a C typedef struct declaration for the given struct name.
  *
@@ -41,35 +87,9 @@ function generateStructHeader(name: string, input: IHeaderTypeInput): string {
 
   // Iterate fields in insertion order (Map preserves order)
   for (const [fieldName, fieldType] of fields) {
-    // Issue #502/#522: Convert C++ namespace types from _ to :: format using shared utility
-    const convertedType = CppNamespaceUtils.convertToCppNamespace(
-      fieldType,
-      input.symbolTable,
-    );
-    const cType = mapType(convertedType);
+    const cType = resolveFieldCType(fieldType, input);
     const dims = dimensions?.get(fieldName);
-    const dimSuffix =
-      dims && dims.length > 0 ? dims.map((d) => `[${d}]`).join("") : "";
-
-    // Issue #461: Handle string<N> types which map to char[N+1]
-    // The embedded dimension must come after array dimensions in C syntax
-    // Example: string<64> arr[4] -> char arr[4][65], not char[65] arr[4]
-    //
-    // Fix: When dims already include the string capacity (from StructCollector),
-    // use dimSuffix directly. Only extract embedded dim when no dims provided.
-    const embeddedMatch = /^(\w+)\[(\d+)\]$/.exec(cType);
-    if (embeddedMatch) {
-      const baseType = embeddedMatch[1];
-      const embeddedDim = embeddedMatch[2];
-      // dims already includes string capacity, so just use dimSuffix
-      if (dims && dims.length > 0) {
-        lines.push(`    ${baseType} ${fieldName}${dimSuffix};`);
-      } else {
-        lines.push(`    ${baseType} ${fieldName}[${embeddedDim}];`);
-      }
-    } else {
-      lines.push(`    ${cType} ${fieldName}${dimSuffix};`);
-    }
+    lines.push(generateFieldLine(fieldName, cType, dims));
   }
 
   lines.push(`} ${name};`);

package/src/transpiler/state/CodeGenState.ts

@@ -30,6 +30,7 @@ import ICallbackTypeInfo from "../output/codegen/types/ICallbackTypeInfo";
 import ITargetCapabilities from "../output/codegen/types/ITargetCapabilities";
 import TOverflowBehavior from "../output/codegen/types/TOverflowBehavior";
 import TYPE_WIDTH from "../output/codegen/types/TYPE_WIDTH";
+import type ICodeGenApi from "../output/codegen/types/ICodeGenApi";
 import TypeResolver from "../../utils/TypeResolver";
 
 /**
@@ -73,10 +74,26 @@ export default class CodeGenState {
   // ===========================================================================
 
   /**
-   * Reference to the CodeGenerator instance for handlers to call methods.
-   * Typed as unknown to avoid circular dependencies - handlers cast as needed.
+   * Reference to the CodeGenerator instance for handlers to call its methods,
+   * typed to the method subset they use (ICodeGenApi). `import type` keeps this a
+   * compile-time-only edge, and CodeGenState already imports sibling types from
+   * output/codegen/types, so this introduces no runtime/circular dependency.
    */
-  static generator: unknown = null;
+  static generator: ICodeGenApi | null = null;
+
+  /**
+   * The CodeGenerator instance, asserted present. Handlers call this instead of
+   * each casting `generator` themselves — one source of truth for the access and
+   * null-check (the generator is always set before any handler runs).
+   */
+  static requireGenerator(): ICodeGenApi {
+    if (CodeGenState.generator === null) {
+      throw new Error(
+        "CodeGenState.generator is not set; codegen accessed before initialization.",
+      );
+    }
+    return CodeGenState.generator;
+  }
 
   // ===========================================================================
   // SYMBOL DATA (read-only after initialization)
@@ -142,9 +159,6 @@ export default class CodeGenState {
   /** Tracks which parameters are modified (directly or transitively) */
   static modifiedParameters: Map<string, Set<string>> = new Map();
 
-  /** Issue #579: Parameters with subscript access (must become pointers) */
-  static subscriptAccessedParameters: Map<string, Set<string>> = new Map();
-
   /** Parameters that should pass by value (small, unmodified primitives) */
   static passByValueParams: Map<string, Set<string>> = new Map();
 
@@ -217,6 +231,12 @@ export default class CodeGenState {
   /** Whether we're inside a function body */
   static inFunctionBody: boolean = false;
 
+  /** Whether we're generating the RHS of a variable declaration initializer.
+   *  When true, struct literals use { .field = value } instead of (Type){ .field = value }
+   *  because plain designated initializers are valid C99 at any scope, while compound
+   *  literals are not constant expressions and fail at file scope on GCC < 13. */
+  static inDeclarationInit: boolean = false;
+
   /** Expected type for struct initializers and enum inference */
   static expectedType: string | null = null;
 
@@ -357,7 +377,6 @@ export default class CodeGenState {
 
     // Pass-by-value analysis
     this.modifiedParameters = new Map();
-    this.subscriptAccessedParameters = new Map();
     this.passByValueParams = new Map();
     this.functionCallGraph = new Map();
     this.functionParamLists = new Map();
@@ -381,6 +400,7 @@ export default class CodeGenState {
     // Generation state
     this.indentLevel = 0;
     this.inFunctionBody = false;
+    this.inDeclarationInit = false;
     this.expectedType = null;
     this.suppressBareEnumResolution = false;
     this.mainArgsName = null;
@@ -476,6 +496,49 @@ export default class CodeGenState {
     }
   }
 
+  /** Execute fn with inDeclarationInit=true, restoring prior value on exit. */
+  static withDeclarationInit<T>(fn: () => T): T {
+    const saved = this.inDeclarationInit;
+    this.inDeclarationInit = true;
+    try {
+      return fn();
+    } finally {
+      this.inDeclarationInit = saved;
+    }
+  }
+
+  /** Execute fn with inDeclarationInit=false, restoring prior value on exit.
+   *  Used in sub-expression contexts (function args, ternary arms) where
+   *  plain designated initializers are not valid C. */
+  static withoutDeclarationInit<T>(fn: () => T): T {
+    const saved = this.inDeclarationInit;
+    this.inDeclarationInit = false;
+    try {
+      return fn();
+    } finally {
+      this.inDeclarationInit = saved;
+    }
+  }
+
+  /**
+   * Execute fn with expectedType=null, restoring prior value on exit.
+   * Issue #1032: Used in comparison contexts (relational/equality expressions)
+   * where MISRA 7.2 U suffix should NOT be applied - comparing `i32 < 0`
+   * should not generate `signedIdx < 0U` which changes comparison semantics.
+   */
+  static withoutExpectedType<T>(fn: () => T): T {
+    const savedType = this.expectedType;
+    const savedSuppress = this.suppressBareEnumResolution;
+    this.expectedType = null;
+    this.suppressBareEnumResolution = false;
+    try {
+      return fn();
+    } finally {
+      this.expectedType = savedType;
+      this.suppressBareEnumResolution = savedSuppress;
+    }
+  }
+
   // ===========================================================================
   // CONVENIENCE LOOKUP METHODS
   // ===========================================================================
@@ -720,15 +783,6 @@ export default class CodeGenState {
     return this.passByValueParams.get(funcName)?.has(paramName) ?? false;
   }
 
-  /**
-   * Check if a parameter has subscript access.
-   */
-  static hasSubscriptAccess(funcName: string, paramName: string): boolean {
-    return (
-      this.subscriptAccessedParameters.get(funcName)?.has(paramName) ?? false
-    );
-  }
-
   /**
    * Get the function signature for a function.
    */
@@ -1136,14 +1190,29 @@ export default class CodeGenState {
   }
 
   /**
-   * Check if a scope variable has an opaque type (and is thus a pointer).
-   * Used during access generation to determine if & prefix is needed.
+   * Check if generated code accesses an opaque scope variable (and is thus
+   * already a pointer). Used during argument generation to decide whether an
+   * address-of (&) prefix is needed.
    *
-   * @param qualifiedName - The fully qualified variable name (e.g., "MyScope_widget")
-   * @returns true if this is an opaque scope variable (already a pointer)
+   * Handles two forms:
+   * - Direct access:        "MyScope_widget"     → the handle itself (pointer)
+   * - Array-element access: "MyScope_widgets[i]" → an element of an opaque
+   *   handle array, which is itself a pointer (Issue #996)
+   *
+   * @param generatedCode - The generated access expression (e.g. "UI_widgets[i]")
+   * @returns true if this resolves to an opaque scope variable (already a pointer)
    */
-  static isOpaqueScopeVariable(qualifiedName: string): boolean {
-    return this.opaqueScopeVariables.has(qualifiedName);
+  static isOpaqueScopeVariableAccess(generatedCode: string): boolean {
+    if (this.opaqueScopeVariables.has(generatedCode)) {
+      return true;
+    }
+    // Issue #996: An element of an opaque-handle array is already a pointer.
+    // Match on the base array name that precedes the subscript.
+    const bracketIndex = generatedCode.indexOf("[");
+    if (bracketIndex === -1) {
+      return false;
+    }
+    return this.opaqueScopeVariables.has(generatedCode.slice(0, bracketIndex));
   }
 
   // ===========================================================================

package/src/transpiler/state/__tests__/CodeGenState.test.ts

@@ -376,6 +376,7 @@ describe("CodeGenState", () => {
             isArray: false,
             isConst: false,
             isPointer: false,
+            isStruct: false,
             arrayDims: "",
           },
         ],
@@ -1011,25 +1012,35 @@ describe("CodeGenState", () => {
   describe("Opaque Scope Variable Helpers (Issue #948)", () => {
     it("markOpaqueScopeVariable adds to opaqueScopeVariables", () => {
       CodeGenState.markOpaqueScopeVariable("MyScope_widget");
-      expect(CodeGenState.isOpaqueScopeVariable("MyScope_widget")).toBe(true);
+      expect(CodeGenState.isOpaqueScopeVariableAccess("MyScope_widget")).toBe(
+        true,
+      );
     });
 
-    it("isOpaqueScopeVariable returns false for unknown variable", () => {
-      expect(CodeGenState.isOpaqueScopeVariable("Unknown_var")).toBe(false);
+    it("isOpaqueScopeVariableAccess returns false for unknown variable", () => {
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Unknown_var")).toBe(
+        false,
+      );
     });
 
-    it("isOpaqueScopeVariable returns true for marked variable", () => {
+    it("isOpaqueScopeVariableAccess returns true for marked variable", () => {
       CodeGenState.markOpaqueScopeVariable("Gui_display");
-      expect(CodeGenState.isOpaqueScopeVariable("Gui_display")).toBe(true);
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Gui_display")).toBe(
+        true,
+      );
     });
 
     it("reset clears opaqueScopeVariables", () => {
       CodeGenState.markOpaqueScopeVariable("Test_opaque");
-      expect(CodeGenState.isOpaqueScopeVariable("Test_opaque")).toBe(true);
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Test_opaque")).toBe(
+        true,
+      );
 
       CodeGenState.reset();
 
-      expect(CodeGenState.isOpaqueScopeVariable("Test_opaque")).toBe(false);
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Test_opaque")).toBe(
+        false,
+      );
     });
 
     it("handles multiple opaque scope variables", () => {
@@ -1037,10 +1048,241 @@ describe("CodeGenState", () => {
       CodeGenState.markOpaqueScopeVariable("Scope1_display");
       CodeGenState.markOpaqueScopeVariable("Scope2_handle");
 
-      expect(CodeGenState.isOpaqueScopeVariable("Scope1_widget")).toBe(true);
-      expect(CodeGenState.isOpaqueScopeVariable("Scope1_display")).toBe(true);
-      expect(CodeGenState.isOpaqueScopeVariable("Scope2_handle")).toBe(true);
-      expect(CodeGenState.isOpaqueScopeVariable("Scope1_other")).toBe(false);
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Scope1_widget")).toBe(
+        true,
+      );
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Scope1_display")).toBe(
+        true,
+      );
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Scope2_handle")).toBe(
+        true,
+      );
+      expect(CodeGenState.isOpaqueScopeVariableAccess("Scope1_other")).toBe(
+        false,
+      );
+    });
+
+    // Issue #996: An element of an opaque-handle array is itself a pointer.
+    it("isOpaqueScopeVariableAccess matches array-element access of an opaque array", () => {
+      CodeGenState.markOpaqueScopeVariable("UI_widgets");
+
+      expect(CodeGenState.isOpaqueScopeVariableAccess("UI_widgets[i]")).toBe(
+        true,
+      );
+      expect(CodeGenState.isOpaqueScopeVariableAccess("UI_widgets[0]")).toBe(
+        true,
+      );
+    });
+
+    it("isOpaqueScopeVariableAccess does not match subscript of a non-opaque array", () => {
+      // Base array name was never marked opaque.
+      expect(CodeGenState.isOpaqueScopeVariableAccess("UI_counts[i]")).toBe(
+        false,
+      );
+    });
+
+    it("isOpaqueScopeVariableAccess does not match a different array that shares a prefix", () => {
+      CodeGenState.markOpaqueScopeVariable("UI_widgets");
+
+      // "UI_widgetsExtra" is a distinct variable, not a subscript of UI_widgets.
+      expect(CodeGenState.isOpaqueScopeVariableAccess("UI_widgetsExtra")).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("withDeclarationInit()", () => {
+    it("sets inDeclarationInit to true during callback", () => {
+      CodeGenState.inDeclarationInit = false;
+      let valueInside = false;
+
+      CodeGenState.withDeclarationInit(() => {
+        valueInside = CodeGenState.inDeclarationInit;
+      });
+
+      expect(valueInside).toBe(true);
+    });
+
+    it("restores prior value after callback", () => {
+      CodeGenState.inDeclarationInit = false;
+
+      CodeGenState.withDeclarationInit(() => {
+        // inside: true
+      });
+
+      expect(CodeGenState.inDeclarationInit).toBe(false);
+    });
+
+    it("restores prior value even when already true", () => {
+      CodeGenState.inDeclarationInit = true;
+
+      CodeGenState.withDeclarationInit(() => {
+        expect(CodeGenState.inDeclarationInit).toBe(true);
+      });
+
+      expect(CodeGenState.inDeclarationInit).toBe(true);
+    });
+
+    it("returns the callback result", () => {
+      const result = CodeGenState.withDeclarationInit(() => "hello");
+      expect(result).toBe("hello");
+    });
+
+    it("restores prior value on exception", () => {
+      CodeGenState.inDeclarationInit = false;
+
+      expect(() =>
+        CodeGenState.withDeclarationInit(() => {
+          throw new Error("test error");
+        }),
+      ).toThrow("test error");
+
+      expect(CodeGenState.inDeclarationInit).toBe(false);
+    });
+  });
+
+  describe("withoutDeclarationInit()", () => {
+    it("sets inDeclarationInit to false during callback", () => {
+      CodeGenState.inDeclarationInit = true;
+      let valueInside = true;
+
+      CodeGenState.withoutDeclarationInit(() => {
+        valueInside = CodeGenState.inDeclarationInit;
+      });
+
+      expect(valueInside).toBe(false);
+    });
+
+    it("restores prior value after callback", () => {
+      CodeGenState.inDeclarationInit = true;
+
+      CodeGenState.withoutDeclarationInit(() => {
+        // inside: false
+      });
+
+      expect(CodeGenState.inDeclarationInit).toBe(true);
+    });
+
+    it("restores prior value even when already false", () => {
+      CodeGenState.inDeclarationInit = false;
+
+      CodeGenState.withoutDeclarationInit(() => {
+        expect(CodeGenState.inDeclarationInit).toBe(false);
+      });
+
+      expect(CodeGenState.inDeclarationInit).toBe(false);
+    });
+
+    it("returns the callback result", () => {
+      const result = CodeGenState.withoutDeclarationInit(() => 42);
+      expect(result).toBe(42);
+    });
+
+    it("restores prior value on exception", () => {
+      CodeGenState.inDeclarationInit = true;
+
+      expect(() =>
+        CodeGenState.withoutDeclarationInit(() => {
+          throw new Error("test error");
+        }),
+      ).toThrow("test error");
+
+      expect(CodeGenState.inDeclarationInit).toBe(true);
+    });
+
+    it("nests correctly with withDeclarationInit", () => {
+      CodeGenState.inDeclarationInit = false;
+
+      CodeGenState.withDeclarationInit(() => {
+        expect(CodeGenState.inDeclarationInit).toBe(true);
+
+        CodeGenState.withoutDeclarationInit(() => {
+          expect(CodeGenState.inDeclarationInit).toBe(false);
+        });
+
+        expect(CodeGenState.inDeclarationInit).toBe(true);
+      });
+
+      expect(CodeGenState.inDeclarationInit).toBe(false);
+    });
+  });
+
+  describe("withoutExpectedType()", () => {
+    it("clears expectedType during callback", () => {
+      CodeGenState.expectedType = "u32";
+      let typeInside: string | null = "notCleared";
+
+      CodeGenState.withoutExpectedType(() => {
+        typeInside = CodeGenState.expectedType;
+      });
+
+      expect(typeInside).toBeNull();
+    });
+
+    it("clears suppressBareEnumResolution during callback", () => {
+      CodeGenState.suppressBareEnumResolution = true;
+      let suppressInside = true;
+
+      CodeGenState.withoutExpectedType(() => {
+        suppressInside = CodeGenState.suppressBareEnumResolution;
+      });
+
+      expect(suppressInside).toBe(false);
+    });
+
+    it("restores expectedType after callback", () => {
+      CodeGenState.expectedType = "i32";
+
+      CodeGenState.withoutExpectedType(() => {
+        // inside: null
+      });
+
+      expect(CodeGenState.expectedType).toBe("i32");
+    });
+
+    it("restores suppressBareEnumResolution after callback", () => {
+      CodeGenState.suppressBareEnumResolution = true;
+
+      CodeGenState.withoutExpectedType(() => {
+        // inside: false
+      });
+
+      expect(CodeGenState.suppressBareEnumResolution).toBe(true);
+    });
+
+    it("returns the callback result", () => {
+      const result = CodeGenState.withoutExpectedType(() => 123);
+      expect(result).toBe(123);
+    });
+
+    it("restores values on exception", () => {
+      CodeGenState.expectedType = "bool";
+      CodeGenState.suppressBareEnumResolution = true;
+
+      expect(() =>
+        CodeGenState.withoutExpectedType(() => {
+          throw new Error("test error");
+        }),
+      ).toThrow("test error");
+
+      expect(CodeGenState.expectedType).toBe("bool");
+      expect(CodeGenState.suppressBareEnumResolution).toBe(true);
+    });
+
+    it("handles null expectedType correctly", () => {
+      CodeGenState.expectedType = null;
+      CodeGenState.suppressBareEnumResolution = false;
+
+      let executed = false;
+      CodeGenState.withoutExpectedType(() => {
+        executed = true;
+        expect(CodeGenState.expectedType).toBeNull();
+        expect(CodeGenState.suppressBareEnumResolution).toBe(false);
+      });
+
+      expect(executed).toBe(true);
+      expect(CodeGenState.expectedType).toBeNull();
+      expect(CodeGenState.suppressBareEnumResolution).toBe(false);
     });
   });
 });

package/src/transpiler/types/ICachedFileEntry.ts

@@ -26,6 +26,13 @@ interface ICachedFileEntry {
   structTagAliases?: Array<[string, string]>;
   /** Issue #958: Struct tags that have full definitions (bodies) */
   structTagsWithBodies?: string[];
+  /**
+   * Issue #985: This header could not be preprocessed standalone and fell back
+   * to raw content, so its cached symbols are degraded (phantom struct bodies,
+   * missing/by-value framework signatures). Persisted so a warm-cache build
+   * still triggers the external-declaration recovery pass and re-applies the fix.
+   */
+  preprocessFailed?: boolean;
 }
 
 export default ICachedFileEntry;

package/src/utils/LiteralUtils.ts

@@ -68,9 +68,32 @@ class LiteralUtils {
       );
     }
 
+    // Issue #1010: Float literals (0.0, 0.0f, .0, etc.)
+    if (ctx.FLOAT_LITERAL()) {
+      return LiteralUtils.isFloatZero(text);
+    }
+
     return false;
   }
 
+  /**
+   * Check if a float literal string represents zero.
+   * Issue #1010: Detect float zero for division-by-zero checking.
+   *
+   * Handles: 0.0, .0, 0., 0.0f, 0.0F, 0.0e0, 0.0E0, etc.
+   *
+   * @param text - The float literal text
+   * @returns true if the float is zero
+   */
+  static isFloatZero(text: string): boolean {
+    // Remove optional float suffix (f, F)
+    const withoutSuffix = text.replace(/[fF]$/, "");
+
+    // Parse to number and check if zero
+    const value = Number.parseFloat(withoutSuffix);
+    return value === 0;
+  }
+
   /**
    * Check if a literal is a floating-point number.
    *