c-next 0.2.9 → 0.2.10

package/src/transpiler/output/codegen/helpers/__tests__/NarrowingCastHelper.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Unit tests for NarrowingCastHelper
+ * Issue #845: MISRA C:2012 Rule 10.3 compliance
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import NarrowingCastHelper from "../NarrowingCastHelper.js";
+import CodeGenState from "../../../../state/CodeGenState.js";
+
+describe("NarrowingCastHelper", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
+  describe("needsCast", () => {
+    it("returns false for same type", () => {
+      expect(NarrowingCastHelper.needsCast("u32", "u32")).toBe(false);
+      expect(NarrowingCastHelper.needsCast("u8", "u8")).toBe(false);
+      expect(NarrowingCastHelper.needsCast("bool", "bool")).toBe(false);
+    });
+
+    it("returns false for widening (u8 -> u32)", () => {
+      expect(NarrowingCastHelper.needsCast("u8", "u32")).toBe(false);
+      expect(NarrowingCastHelper.needsCast("u16", "u32")).toBe(false);
+      expect(NarrowingCastHelper.needsCast("i8", "i32")).toBe(false);
+    });
+
+    it("returns true for narrowing (u32 -> u8)", () => {
+      expect(NarrowingCastHelper.needsCast("u32", "u8")).toBe(true);
+      expect(NarrowingCastHelper.needsCast("u32", "u16")).toBe(true);
+      expect(NarrowingCastHelper.needsCast("i32", "i8")).toBe(true);
+    });
+
+    it("returns true for int -> smaller unsigned (C promotion result)", () => {
+      expect(NarrowingCastHelper.needsCast("int", "u8")).toBe(true);
+      expect(NarrowingCastHelper.needsCast("int", "u16")).toBe(true);
+      expect(NarrowingCastHelper.needsCast("int", "i8")).toBe(true);
+    });
+
+    it("returns true for int -> bool (different essential type)", () => {
+      expect(NarrowingCastHelper.needsCast("int", "bool")).toBe(true);
+      expect(NarrowingCastHelper.needsCast("u32", "bool")).toBe(true);
+    });
+
+    it("returns true for char literal type -> u8", () => {
+      expect(NarrowingCastHelper.needsCast("int", "u8")).toBe(true);
+    });
+  });
+
+  describe("wrap (C mode)", () => {
+    beforeEach(() => {
+      CodeGenState.cppMode = false;
+    });
+
+    it("returns expression unchanged for same type", () => {
+      expect(NarrowingCastHelper.wrap("x", "u32", "u32")).toBe("x");
+    });
+
+    it("returns expression unchanged for widening", () => {
+      expect(NarrowingCastHelper.wrap("x", "u8", "u32")).toBe("x");
+    });
+
+    it("adds C cast for narrowing u32 -> u8", () => {
+      const expr = "((value >> 0U) & 0xFFU)";
+      expect(NarrowingCastHelper.wrap(expr, "u32", "u8")).toBe(
+        "(uint8_t)((value >> 0U) & 0xFFU)",
+      );
+    });
+
+    it("adds C cast for narrowing u32 -> u16", () => {
+      const expr = "((value >> 0U) & 0xFFFFU)";
+      expect(NarrowingCastHelper.wrap(expr, "u32", "u16")).toBe(
+        "(uint16_t)((value >> 0U) & 0xFFFFU)",
+      );
+    });
+
+    it("adds C cast for int -> u8 (C promotion result)", () => {
+      const expr = "((flags >> 3) & 0x7)";
+      expect(NarrowingCastHelper.wrap(expr, "int", "u8")).toBe(
+        "(uint8_t)((flags >> 3) & 0x7)",
+      );
+    });
+
+    it("uses != 0U comparison for bool target (MISRA 10.5)", () => {
+      const expr = "((flags >> 0) & 1)";
+      expect(NarrowingCastHelper.wrap(expr, "int", "bool")).toBe(
+        "((((flags >> 0) & 1)) != 0U)",
+      );
+    });
+
+    it("adds cast for char literal to u8", () => {
+      expect(NarrowingCastHelper.wrap("'A'", "int", "u8")).toBe("(uint8_t)'A'");
+    });
+  });
+
+  describe("wrap (C++ mode)", () => {
+    beforeEach(() => {
+      CodeGenState.cppMode = true;
+    });
+
+    it("uses static_cast for narrowing", () => {
+      const expr = "((value >> 0U) & 0xFFU)";
+      expect(NarrowingCastHelper.wrap(expr, "u32", "u8")).toBe(
+        "static_cast<uint8_t>(((value >> 0U) & 0xFFU))",
+      );
+    });
+
+    it("uses != 0U for bool (same as C mode)", () => {
+      const expr = "((flags >> 0) & 1)";
+      expect(NarrowingCastHelper.wrap(expr, "int", "bool")).toBe(
+        "((((flags >> 0) & 1)) != 0U)",
+      );
+    });
+  });
+
+  describe("getPromotedType", () => {
+    it("returns 'int' for u8 (promoted)", () => {
+      expect(NarrowingCastHelper.getPromotedType("u8")).toBe("int");
+    });
+
+    it("returns 'int' for i8 (promoted)", () => {
+      expect(NarrowingCastHelper.getPromotedType("i8")).toBe("int");
+    });
+
+    it("returns 'int' for u16 (promoted)", () => {
+      expect(NarrowingCastHelper.getPromotedType("u16")).toBe("int");
+    });
+
+    it("returns 'int' for i16 (promoted)", () => {
+      expect(NarrowingCastHelper.getPromotedType("i16")).toBe("int");
+    });
+
+    it("returns same type for u32 (no promotion)", () => {
+      expect(NarrowingCastHelper.getPromotedType("u32")).toBe("u32");
+    });
+
+    it("returns same type for i32 (no promotion)", () => {
+      expect(NarrowingCastHelper.getPromotedType("i32")).toBe("i32");
+    });
+
+    it("returns same type for u64 (no promotion)", () => {
+      expect(NarrowingCastHelper.getPromotedType("u64")).toBe("u64");
+    });
+
+    it("returns same type for i64 (no promotion)", () => {
+      expect(NarrowingCastHelper.getPromotedType("i64")).toBe("i64");
+    });
+
+    it("returns 'int' for bool (promoted)", () => {
+      expect(NarrowingCastHelper.getPromotedType("bool")).toBe("int");
+    });
+
+    it("returns same type for unknown types (conservative)", () => {
+      expect(NarrowingCastHelper.getPromotedType("custom_type")).toBe(
+        "custom_type",
+      );
+    });
+  });
+});

package/src/transpiler/output/codegen/helpers/__tests__/TypeRegistrationEngine.test.ts

@@ -39,6 +39,7 @@ function createMockSymbols(): ICodeGenSymbols {
     scopePrivateConstValues: new Map(),
     functionReturnTypes: new Map(),
     getSingleFunctionForVariable: () => null,
+    opaqueTypes: new Set(),
     hasPublicSymbols: () => false,
   };
 }

package/src/transpiler/output/codegen/types/COMPOUND_TO_BINARY.ts

@@ -0,0 +1,21 @@
+/**
+ * Map compound assignment operator to its binary operator equivalent.
+ *
+ * Shared constant used by:
+ * - SimpleHandler.ts: MISRA 10.3 compound assignment expansion
+ * - AtomicGenerator.ts: Atomic compound operation expansion
+ */
+const COMPOUND_TO_BINARY: Record<string, string> = {
+  "+=": "+",
+  "-=": "-",
+  "*=": "*",
+  "/=": "/",
+  "%=": "%",
+  "&=": "&",
+  "|=": "|",
+  "^=": "^",
+  "<<=": "<<",
+  ">>=": ">>",
+};
+
+export default COMPOUND_TO_BINARY;

package/src/transpiler/output/codegen/types/IArrayAccessInfo.ts

@@ -19,6 +19,8 @@ type IArrayAccessInfo = {
   widthExpr?: string;
   /** Type info for the variable being accessed */
   typeInfo?: TTypeInfo;
+  /** Target type for narrowing cast (e.g., "u8" when extracting to uint8_t) */
+  targetType?: string;
   /** Source line for error messages */
   line: number;
 };

package/src/transpiler/state/CodeGenState.ts

@@ -278,6 +278,18 @@ export default class CodeGenState {
   /** Issue #473: IRQ wrappers for critical sections */
   static needsIrqWrappers: boolean = false;
 
+  // ===========================================================================
+  // OPAQUE TYPE SCOPE VARIABLES (Issue #948)
+  // ===========================================================================
+
+  /**
+   * Tracks scope variables with opaque (forward-declared) struct types.
+   * These are generated as pointers with NULL initialization and should
+   * be passed directly (not with &) since they're already pointers.
+   * Maps qualified name (e.g., "MyScope_widget") to true.
+   */
+  private static opaqueScopeVariables: Set<string> = new Set();
+
   // ===========================================================================
   // C++ MODE STATE (Issue #250)
   // ===========================================================================
@@ -400,6 +412,9 @@ export default class CodeGenState {
     this.pendingCppClassAssignments = [];
     this.selfIncludeAdded = false;
 
+    // Issue #948: Opaque scope variables (reset per-file)
+    this.opaqueScopeVariables = new Set();
+
     // Source paths
     this.sourcePath = null;
     this.includeDirs = [];
@@ -504,6 +519,15 @@ export default class CodeGenState {
     return this.symbols?.knownRegisters.has(name) ?? false;
   }
 
+  /**
+   * Issue #948: Check if a type name is an opaque (forward-declared) struct type.
+   * Opaque types are incomplete types that can only be used as pointers.
+   * Example: `typedef struct _widget_t widget_t;` without a body makes `widget_t` opaque.
+   */
+  static isOpaqueType(typeName: string): boolean {
+    return this.symbols?.opaqueTypes.has(typeName) ?? false;
+  }
+
   /**
    * Get type info for a variable.
    * Checks local typeRegistry first, then falls back to SymbolTable
@@ -1046,6 +1070,31 @@ export default class CodeGenState {
     return this.floatShadowCurrent.has(name);
   }
 
+  // ===========================================================================
+  // OPAQUE SCOPE VARIABLE HELPERS (Issue #948)
+  // ===========================================================================
+
+  /**
+   * Mark a scope variable as having an opaque (forward-declared) struct type.
+   * These are generated as pointers with NULL initialization.
+   *
+   * @param qualifiedName - The fully qualified variable name (e.g., "MyScope_widget")
+   */
+  static markOpaqueScopeVariable(qualifiedName: string): void {
+    this.opaqueScopeVariables.add(qualifiedName);
+  }
+
+  /**
+   * Check if a scope variable has an opaque type (and is thus a pointer).
+   * Used during access generation to determine if & 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)
+   */
+  static isOpaqueScopeVariable(qualifiedName: string): boolean {
+    return this.opaqueScopeVariables.has(qualifiedName);
+  }
+
   // ===========================================================================
   // C++ MODE HELPERS
   // ===========================================================================

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

@@ -69,6 +69,7 @@ function createMockSymbols(
     structFieldArrays: Map<string, Set<string>>;
     functionReturnTypes: Map<string, string>;
     scopeMemberVisibility: Map<string, Map<string, "public" | "private">>;
+    opaqueTypes: Set<string>;
   }> = {},
 ): ICodeGenSymbols {
   return {
@@ -95,6 +96,7 @@ function createMockSymbols(
     scopeVariableUsage: new Map(),
     scopePrivateConstValues: new Map(),
     functionReturnTypes: overrides.functionReturnTypes ?? new Map(),
+    opaqueTypes: overrides.opaqueTypes ?? new Set(),
     getSingleFunctionForVariable: () => null,
     hasPublicSymbols: () => false,
   };
@@ -714,6 +716,21 @@ describe("CodeGenState", () => {
       expect(CodeGenState.isKnownScope("MyScope")).toBe(true);
       expect(CodeGenState.isKnownScope("UnknownScope")).toBe(false);
     });
+
+    it("isOpaqueType returns false without symbols", () => {
+      CodeGenState.symbols = null;
+      expect(CodeGenState.isOpaqueType("widget_t")).toBe(false);
+    });
+
+    it("isOpaqueType returns true for opaque type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        opaqueTypes: new Set(["widget_t", "display_t"]),
+      });
+
+      expect(CodeGenState.isOpaqueType("widget_t")).toBe(true);
+      expect(CodeGenState.isOpaqueType("display_t")).toBe(true);
+      expect(CodeGenState.isOpaqueType("Point")).toBe(false);
+    });
   });
 
   describe("Local Variable Helpers", () => {
@@ -848,4 +865,40 @@ describe("CodeGenState", () => {
       expect(result.get("Simple")?.has("value")).toBe(true);
     });
   });
+
+  describe("Opaque Scope Variable Helpers (Issue #948)", () => {
+    it("markOpaqueScopeVariable adds to opaqueScopeVariables", () => {
+      CodeGenState.markOpaqueScopeVariable("MyScope_widget");
+      expect(CodeGenState.isOpaqueScopeVariable("MyScope_widget")).toBe(true);
+    });
+
+    it("isOpaqueScopeVariable returns false for unknown variable", () => {
+      expect(CodeGenState.isOpaqueScopeVariable("Unknown_var")).toBe(false);
+    });
+
+    it("isOpaqueScopeVariable returns true for marked variable", () => {
+      CodeGenState.markOpaqueScopeVariable("Gui_display");
+      expect(CodeGenState.isOpaqueScopeVariable("Gui_display")).toBe(true);
+    });
+
+    it("reset clears opaqueScopeVariables", () => {
+      CodeGenState.markOpaqueScopeVariable("Test_opaque");
+      expect(CodeGenState.isOpaqueScopeVariable("Test_opaque")).toBe(true);
+
+      CodeGenState.reset();
+
+      expect(CodeGenState.isOpaqueScopeVariable("Test_opaque")).toBe(false);
+    });
+
+    it("handles multiple opaque scope variables", () => {
+      CodeGenState.markOpaqueScopeVariable("Scope1_widget");
+      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);
+    });
+  });
 });

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

@@ -35,6 +35,7 @@ function createMockSymbolInfo(enumName?: string): ICodeGenSymbols {
     scopePrivateConstValues: new Map(),
     functionReturnTypes: new Map(),
     getSingleFunctionForVariable: () => null,
+    opaqueTypes: new Set(),
     hasPublicSymbols: () => false,
   };
 }

package/src/transpiler/types/ICachedFileEntry.ts

@@ -18,6 +18,8 @@ interface ICachedFileEntry {
   needsStructKeyword?: string[];
   /** Issue #208: Enum bit widths from typed enums (enum name -> bit width) */
   enumBitWidth?: Record<string, number>;
+  /** Issue #948: Opaque types (forward-declared struct types) */
+  opaqueTypes?: string[];
 }
 
 export default ICachedFileEntry;

package/src/transpiler/types/ICodeGenSymbols.ts

@@ -113,6 +113,14 @@ interface ICodeGenSymbols {
    */
   readonly functionReturnTypes: ReadonlyMap<string, string>;
 
+  // === Opaque Types (Issue #948) ===
+
+  /**
+   * Issue #948: Types that are opaque (forward-declared structs).
+   * Variables of these types should be generated as pointers.
+   */
+  readonly opaqueTypes: ReadonlySet<string>;
+
   /**
    * Check if a scope variable is used in only one function.
    * Returns the function name if single-function, null otherwise.

package/src/utils/BitUtils.ts

@@ -1,3 +1,12 @@
+import TYPE_MAP from "../transpiler/output/codegen/types/TYPE_MAP";
+
+/**
+ * Types that need explicit cast for MISRA 10.3 compliance.
+ * These types are narrower than int (32-bit) and need casts after
+ * bit manipulation operations which promote to int.
+ */
+const NARROW_TYPES = new Set(["u8", "u16", "i8", "i16"]);
+
 /**
  * Bit manipulation utilities for C code generation.
  * Pure functions that generate C code strings for bit operations.
@@ -102,6 +111,22 @@ class BitUtils {
     return `0x${value.toString(16).toUpperCase()}U`;
   }
 
+  /**
+   * Wrap an expression with a cast for MISRA 10.3 compliance on narrow types.
+   * Bit manipulation operations promote to int; this casts back to the target type.
+   *
+   * @param expr - The expression to potentially wrap
+   * @param targetType - The C-Next type name (e.g., "u8", "u16")
+   * @returns Expression wrapped with cast if narrow, or original expression
+   */
+  private static wrapNarrowCast(expr: string, targetType?: string): string {
+    if (!targetType || !NARROW_TYPES.has(targetType)) {
+      return expr;
+    }
+    const cType = TYPE_MAP[targetType] ?? targetType;
+    return `(${cType})(${expr})`;
+  }
+
   /**
    * Generate code to read a single bit from a value.
    * Pattern: ((target >> offset) & 1)
@@ -162,7 +187,8 @@ class BitUtils {
     const valueShift = is64Bit
       ? `((uint64_t)${intValue} << ${offset})`
       : `(${intValue} << ${offset})`;
-    return `${target} = (${target} & ~(${one} << ${offset})) | ${valueShift};`;
+    const rhs = `(${target} & ~(${one} << ${offset})) | ${valueShift}`;
+    return `${target} = ${BitUtils.wrapNarrowCast(rhs, targetType)};`;
   }
 
   /**
@@ -184,7 +210,8 @@ class BitUtils {
     targetType?: string,
   ): string {
     const mask = BitUtils.generateMask(width, targetType);
-    return `${target} = (${target} & ~(${mask} << ${offset})) | ((${value} & ${mask}) << ${offset});`;
+    const rhs = `(${target} & ~(${mask} << ${offset})) | ((${value} & ${mask}) << ${offset})`;
+    return `${target} = ${BitUtils.wrapNarrowCast(rhs, targetType)};`;
   }
 
   /**
@@ -209,7 +236,8 @@ class BitUtils {
     // boolToInt already returns unsigned values (1U/0U) for MISRA 10.1 compliance
     const castPrefix =
       targetType === "u64" || targetType === "i64" ? "(uint64_t)" : "";
-    return `${target} = (${castPrefix}${intValue} << ${offset});`;
+    const rhs = `(${castPrefix}${intValue} << ${offset})`;
+    return `${target} = ${BitUtils.wrapNarrowCast(rhs, targetType)};`;
   }
 
   /**
@@ -232,7 +260,8 @@ class BitUtils {
     targetType?: string,
   ): string {
     const mask = BitUtils.generateMask(width, targetType);
-    return `${target} = ((${value} & ${mask}) << ${offset});`;
+    const rhs = `((${value} & ${mask}) << ${offset})`;
+    return `${target} = ${BitUtils.wrapNarrowCast(rhs, targetType)};`;
   }
 }
 

package/src/utils/cache/CacheManager.ts

@@ -32,7 +32,7 @@ import ESourceLanguage from "../types/ESourceLanguage";
 const defaultFs = NodeFileSystem.instance;
 
 /** Current cache format version - increment when serialization format changes */
-const CACHE_VERSION = 4; // ADR-055 Phase 7: TAnySymbol replaces ISymbol
+const CACHE_VERSION = 5; // Issue #948: Add opaqueTypes to cache
 
 const TRANSPILER_VERSION = packageJson.version;
 
@@ -134,6 +134,7 @@ class CacheManager {
     structFields: Map<string, Map<string, IStructFieldInfo>>;
     needsStructKeyword: string[];
     enumBitWidth: Map<string, number>;
+    opaqueTypes: string[];
   } | null {
     if (!this.cache) return null;
 
@@ -173,6 +174,7 @@ class CacheManager {
       structFields,
       needsStructKeyword: cachedEntry.needsStructKeyword ?? [],
       enumBitWidth,
+      opaqueTypes: cachedEntry.opaqueTypes ?? [],
     };
   }
 
@@ -186,6 +188,7 @@ class CacheManager {
     structFields: Map<string, Map<string, IStructFieldInfo>>,
     needsStructKeyword?: string[],
     enumBitWidth?: Map<string, number>,
+    opaqueTypes?: string[],
   ): void {
     if (!this.cache) return;
 
@@ -229,6 +232,7 @@ class CacheManager {
       structFields: serializedFields,
       needsStructKeyword,
       enumBitWidth: serializedEnumBitWidth,
+      opaqueTypes,
     };
 
     this.cache.setKey(filePath, entry);
@@ -266,6 +270,9 @@ class CacheManager {
       symbolTable,
     );
 
+    // Issue #948: Extract opaque types (forward-declared structs)
+    const opaqueTypes = symbolTable.getAllOpaqueTypes();
+
     // Delegate to existing setSymbols method
     this.setSymbols(
       filePath,
@@ -273,6 +280,7 @@ class CacheManager {
       structFields,
       needsStructKeyword,
       enumBitWidth,
+      opaqueTypes,
     );
   }
 

package/src/utils/cache/__tests__/CacheManager.test.ts

@@ -1492,7 +1492,7 @@ describe("CacheManager", () => {
       const content = mockFs.getWrittenContent("/project/.cnx/config.json");
       expect(content).toBeDefined();
       const newConfig = JSON.parse(content!);
-      expect(newConfig.version).toBe(4); // Current CACHE_VERSION (ADR-055 Phase 7)
+      expect(newConfig.version).toBe(5); // Current CACHE_VERSION (Issue #948 opaqueTypes)
     });
 
     it("should not cache files that do not exist in IFileSystem", async () => {