c-next 0.2.0 → 0.2.2

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

@@ -18,6 +18,7 @@ import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
 import CallExprUtils from "./CallExprUtils";
 import CodeGenState from "../../../../state/CodeGenState";
+import C_TYPE_WIDTH from "../../types/C_TYPE_WIDTH";
 
 /**
  * Issue #304: Wrap argument with static_cast if it's a C++ enum class
@@ -58,6 +59,51 @@ interface IResolvedParam {
   isCrossFile: boolean;
 }
 
+/**
+ * Issue #832: Check if parameter expects address-of for typedef'd pointer types.
+ *
+ * When a parameter type is `T*` and the argument type is `T`, we need to add `&`.
+ * This handles cases like `handle_t` (typedef'd pointer) passed to `handle_t*`.
+ *
+ * IMPORTANT: This should NOT match primitive types like uint8_t, because arrays
+ * of primitives decay to pointers naturally (uint8_t[] → uint8_t*).
+ * It SHOULD match typedef'd pointer types like handle_t → handle_t*.
+ *
+ * @param paramType - The parameter's base type (e.g., "handle_t*")
+ * @param argType - The argument's type (e.g., "handle_t")
+ * @param orchestrator - For type checking (isIntegerType, isFloatType)
+ * @returns true if parameter expects `argType*` (address-of needed)
+ */
+const _parameterExpectsAddressOf = (
+  paramType: string,
+  argType: string,
+  orchestrator: IOrchestrator,
+): boolean => {
+  // Don't add & for primitive types - arrays decay to pointers naturally
+  // e.g., uint8_t[] passed to uint8_t* should NOT get &
+  // Check C-Next primitives (u8, i8, etc.)
+  if (
+    orchestrator.isIntegerType(argType) ||
+    orchestrator.isFloatType(argType) ||
+    CallExprUtils.isKnownPrimitiveType(argType)
+  ) {
+    return false;
+  }
+
+  // Check C standard types (uint8_t, int32_t, etc.)
+  if (argType in C_TYPE_WIDTH) {
+    return false;
+  }
+
+  // paramType should end with * (already checked by caller)
+  // Remove trailing pointer markers to get the base type
+  // Use indexOf/slice instead of regex to avoid ReDoS concerns (SonarCloud S5852)
+  const starIndex = paramType.indexOf("*");
+  const paramBaseType =
+    starIndex >= 0 ? paramType.slice(0, starIndex).trim() : paramType.trim();
+  return paramBaseType === argType;
+};
+
 /**
  * Generate argument code for a C/C++ function call.
  * Handles automatic address-of (&) for struct arguments passed to pointer params.
@@ -87,13 +133,16 @@ const _generateCFunctionArg = (
     }
   }
 
-  // Add & if argument is a struct type (not already a pointer)
+  // Add & if argument needs address-of to match parameter type.
+  // Issue #322: struct types passed to pointer params.
+  // Issue #832: typedef'd pointer types (e.g., handle_t passed to handle_t*).
   const needsAddressOf =
     argType &&
     !argType.endsWith("*") &&
     !argCode.startsWith("&") &&
     !targetParam.isArray &&
-    orchestrator.isStructType(argType);
+    (orchestrator.isStructType(argType) ||
+      _parameterExpectsAddressOf(targetParam.baseType, argType, orchestrator));
 
   if (needsAddressOf) {
     argCode = `&${argCode}`;

package/src/transpiler/output/codegen/generators/expressions/LiteralGenerator.ts

@@ -5,6 +5,7 @@
  * - Boolean literals (true/false) → needs stdbool.h
  * - Float literals with C-Next suffixes (f32 → f, f64 → no suffix)
  * - Integer literals with C-Next suffixes (u64 → ULL, i64 → LL, strip 8/16/32)
+ * - MISRA Rule 7.2: Unsigned suffix for unsigned integer types
  * - String and numeric literals pass through unchanged
  */
 import { LiteralContext } from "../../../../logic/parser/grammar/CNextParser";
@@ -14,19 +15,63 @@ import IGeneratorInput from "../IGeneratorInput";
 import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
 
+/**
+ * Unsigned type patterns for MISRA Rule 7.2 compliance.
+ * Includes both C-Next types (u8, u16, u32, u64) and C types (uint8_t, etc.)
+ */
+const UNSIGNED_64_TYPES = new Set(["u64", "uint64_t"]);
+const UNSIGNED_TYPES = new Set([
+  "u8",
+  "u16",
+  "u32",
+  "uint8_t",
+  "uint16_t",
+  "uint32_t",
+]);
+
+/**
+ * Check if a literal is a numeric integer (decimal, hex, octal, or binary).
+ * Excludes strings, floats, and booleans.
+ */
+function isNumericIntegerLiteral(text: string): boolean {
+  // Exclude strings (quoted)
+  if (text.startsWith('"') || text.startsWith("'")) {
+    return false;
+  }
+  // Exclude booleans
+  if (text === "true" || text === "false") {
+    return false;
+  }
+  // Exclude floats (contain decimal point or exponent without 0x prefix)
+  if (!text.startsWith("0x") && !text.startsWith("0X")) {
+    if (text.includes(".") || /[eE][+-]?\d/.test(text)) {
+      return false;
+    }
+  }
+  // Must start with digit or be hex/binary/octal
+  return /^\d/.test(text) || /^0[xXbBoO]/.test(text);
+}
+
+/**
+ * Check if a literal already has a C unsigned suffix (U, UL, ULL).
+ */
+function hasUnsignedSuffix(text: string): boolean {
+  return /[uU]([lL]{0,2})$/.test(text);
+}
+
 /**
  * Generate C code for a literal value.
  *
  * @param node - The LiteralContext AST node
  * @param _input - Read-only context (unused for literals)
- * @param _state - Current generation state (unused for literals)
+ * @param state - Current generation state (contains expectedType)
  * @param _orchestrator - For delegating to other generators (unused for literals)
  * @returns Generated code and effects (stdbool include for bool literals)
  */
 const generateLiteral = (
   node: LiteralContext,
   _input: IGeneratorInput,
-  _state: IGeneratorState,
+  state: IGeneratorState,
   _orchestrator: IOrchestrator,
 ): IGeneratorOutput => {
   const effects: TGeneratorEffect[] = [];
@@ -35,30 +80,53 @@ const generateLiteral = (
   // Track boolean literal usage to include stdbool.h
   if (literalText === "true" || literalText === "false") {
     effects.push({ type: "include", header: "stdbool" });
+    return { code: literalText, effects };
   }
 
   // ADR-024: Transform C-Next float suffixes to standard C syntax
   // 3.14f32 -> 3.14f (C float)
   // 3.14f64 -> 3.14 (C double, no suffix needed)
-  if (/[fF]32$/.exec(literalText)) {
+  if (/[fF]32$/.test(literalText)) {
     literalText = literalText.replace(/[fF]32$/, "f");
-  } else if (/[fF]64$/.exec(literalText)) {
+    return { code: literalText, effects };
+  }
+  if (/[fF]64$/.test(literalText)) {
     literalText = literalText.replace(/[fF]64$/, "");
+    return { code: literalText, effects };
   }
 
   // Issue #130: Transform C-Next integer suffixes to standard C syntax
   // u8/u16/u32 and i8/i16/i32 suffixes are stripped (C infers from context)
   // u64 -> ULL suffix for 64-bit unsigned
   // i64 -> LL suffix for 64-bit signed
-  if (/[uU]64$/.exec(literalText)) {
+  if (/[uU]64$/.test(literalText)) {
     literalText = literalText.replace(/[uU]64$/, "ULL");
-  } else if (/[iI]64$/.exec(literalText)) {
+    return { code: literalText, effects };
+  }
+  if (/[iI]64$/.test(literalText)) {
     literalText = literalText.replace(/[iI]64$/, "LL");
-  } else if (/[uUiI](8|16|32)$/.exec(literalText)) {
-    // Strip 8/16/32-bit suffixes - C handles these without explicit suffix
+    return { code: literalText, effects };
+  }
+  if (/[uUiI](8|16|32)$/.test(literalText)) {
+    // Strip 8/16/32-bit suffixes - will add U below if needed for MISRA
     literalText = literalText.replace(/[uUiI](8|16|32)$/, "");
   }
 
+  // MISRA Rule 7.2: Add unsigned suffix based on expectedType
+  // Only applies to numeric integer literals without existing unsigned suffix
+  const expectedType = state?.expectedType;
+  if (
+    expectedType &&
+    isNumericIntegerLiteral(literalText) &&
+    !hasUnsignedSuffix(literalText)
+  ) {
+    if (UNSIGNED_64_TYPES.has(expectedType)) {
+      literalText = literalText + "ULL";
+    } else if (UNSIGNED_TYPES.has(expectedType)) {
+      literalText = literalText + "U";
+    }
+  }
+
   return { code: literalText, effects };
 };
 

package/src/transpiler/output/codegen/generators/expressions/__tests__/CallExprGenerator.test.ts

@@ -1270,4 +1270,151 @@ describe("CallExprGenerator", () => {
       expect(markParameterModified).not.toHaveBeenCalled();
     });
   });
+
+  // ========================================================================
+  // Issue #832: Auto-reference for typedef pointer output parameters
+  // ========================================================================
+  describe("Issue #832: typedef pointer output parameters", () => {
+    it("adds & when typedef pointer type is passed to pointer-to-typedef param", () => {
+      // handle_t is typedef'd pointer, create_handle expects handle_t*
+      const argExprs = [createMockExpressionContext("my_handle")];
+      const argCtx = createMockArgListContext(argExprs);
+      const sigs = new Map([
+        [
+          "create_handle",
+          {
+            name: "create_handle",
+            parameters: [
+              {
+                name: "out",
+                baseType: "handle_t*",
+                isConst: false,
+                isArray: false,
+              },
+            ],
+          },
+        ],
+      ]);
+      const typeRegistry = new Map([
+        [
+          "my_handle",
+          { baseType: "handle_t", bitWidth: 0, isArray: false, isConst: false },
+        ],
+      ]);
+      const input = createMockInput({ functionSignatures: sigs, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        isCNextFunction: vi.fn(() => false),
+        getExpressionType: vi.fn(() => "handle_t"),
+        isStructType: vi.fn(() => false), // typedef pointer is not a struct
+        isIntegerType: vi.fn(() => false),
+        isFloatType: vi.fn(() => false),
+      });
+
+      const result = generateFunctionCall(
+        "create_handle",
+        argCtx,
+        input,
+        state,
+        orchestrator,
+      );
+
+      expect(result.code).toBe("create_handle(&my_handle)");
+    });
+
+    it("does not add & for primitive types passed to pointer params (array decay)", () => {
+      // uint8_t[] passed to uint8_t* should NOT get &
+      const argExprs = [createMockExpressionContext("data")];
+      const argCtx = createMockArgListContext(argExprs);
+      const sigs = new Map([
+        [
+          "send_data",
+          {
+            name: "send_data",
+            parameters: [
+              {
+                name: "buf",
+                baseType: "uint8_t*",
+                isConst: false,
+                isArray: false,
+              },
+            ],
+          },
+        ],
+      ]);
+      const typeRegistry = new Map([
+        [
+          "data",
+          { baseType: "uint8_t", bitWidth: 8, isArray: true, isConst: false },
+        ],
+      ]);
+      const input = createMockInput({ functionSignatures: sigs, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        isCNextFunction: vi.fn(() => false),
+        getExpressionType: vi.fn(() => "uint8_t"),
+        isStructType: vi.fn(() => false),
+        isIntegerType: vi.fn(() => false), // uint8_t is C type, not in INTEGER_TYPES
+        isFloatType: vi.fn(() => false),
+      });
+
+      const result = generateFunctionCall(
+        "send_data",
+        argCtx,
+        input,
+        state,
+        orchestrator,
+      );
+
+      // Should NOT add & because uint8_t is in C_TYPE_WIDTH (primitive)
+      expect(result.code).toBe("send_data(data)");
+    });
+
+    it("does not add & when typedef type is passed directly (not to pointer)", () => {
+      // use_handle expects handle_t, not handle_t*
+      const argExprs = [createMockExpressionContext("my_handle")];
+      const argCtx = createMockArgListContext(argExprs);
+      const sigs = new Map([
+        [
+          "use_handle",
+          {
+            name: "use_handle",
+            parameters: [
+              {
+                name: "h",
+                baseType: "handle_t", // NOT a pointer
+                isConst: false,
+                isArray: false,
+              },
+            ],
+          },
+        ],
+      ]);
+      const typeRegistry = new Map([
+        [
+          "my_handle",
+          { baseType: "handle_t", bitWidth: 0, isArray: false, isConst: false },
+        ],
+      ]);
+      const input = createMockInput({ functionSignatures: sigs, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        isCNextFunction: vi.fn(() => false),
+        getExpressionType: vi.fn(() => "handle_t"),
+        isStructType: vi.fn(() => false),
+        isIntegerType: vi.fn(() => false),
+        isFloatType: vi.fn(() => false),
+      });
+
+      const result = generateFunctionCall(
+        "use_handle",
+        argCtx,
+        input,
+        state,
+        orchestrator,
+      );
+
+      expect(result.code).toBe("use_handle(my_handle)");
+    });
+  });
 });

package/src/transpiler/output/codegen/generators/expressions/__tests__/LiteralGenerator.test.ts

@@ -165,4 +165,120 @@ describe("LiteralGenerator", () => {
       expect(result.effects).toEqual([]);
     });
   });
+
+  describe("MISRA Rule 7.2: unsigned suffix for unsigned types", () => {
+    /**
+     * Create mock state with expectedType set.
+     */
+    function createStateWithExpectedType(
+      expectedType: string | null,
+    ): IGeneratorState {
+      return { expectedType } as IGeneratorState;
+    }
+
+    it("should add U suffix to decimal literal when expectedType is u8", () => {
+      const node = createMockLiteral("255");
+      const state = createStateWithExpectedType("u8");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("255U");
+    });
+
+    it("should add U suffix to decimal literal when expectedType is u16", () => {
+      const node = createMockLiteral("60000");
+      const state = createStateWithExpectedType("u16");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("60000U");
+    });
+
+    it("should add U suffix to decimal literal when expectedType is u32", () => {
+      const node = createMockLiteral("4000000000");
+      const state = createStateWithExpectedType("u32");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("4000000000U");
+    });
+
+    it("should add ULL suffix to decimal literal when expectedType is u64", () => {
+      const node = createMockLiteral("42");
+      const state = createStateWithExpectedType("u64");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("42ULL");
+    });
+
+    it("should add U suffix to hex literal when expectedType is u8", () => {
+      const node = createMockLiteral("0xFF");
+      const state = createStateWithExpectedType("u8");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("0xFFU");
+    });
+
+    it("should add U suffix to binary literal when expectedType is u8", () => {
+      const node = createMockLiteral("0b11110000");
+      const state = createStateWithExpectedType("u8");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("0b11110000U");
+    });
+
+    it("should NOT add U suffix when expectedType is signed (i32)", () => {
+      const node = createMockLiteral("42");
+      const state = createStateWithExpectedType("i32");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("42");
+    });
+
+    it("should NOT add U suffix when expectedType is null", () => {
+      const node = createMockLiteral("42");
+      const state = createStateWithExpectedType(null);
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("42");
+    });
+
+    it("should NOT add U suffix to string literals even with unsigned expectedType", () => {
+      const node = createMockLiteral('"hello"');
+      const state = createStateWithExpectedType("u8");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe('"hello"');
+    });
+
+    it("should NOT add U suffix to float literals even with unsigned expectedType", () => {
+      const node = createMockLiteral("3.14");
+      const state = createStateWithExpectedType("u32");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("3.14");
+    });
+
+    it("should NOT double-add U suffix if already present via explicit suffix", () => {
+      const node = createMockLiteral("42u32");
+      const state = createStateWithExpectedType("u32");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      // u32 suffix is stripped, then U is added based on expectedType
+      expect(result.code).toBe("42U");
+    });
+
+    it("should handle uint8_t C type as unsigned", () => {
+      const node = createMockLiteral("42");
+      const state = createStateWithExpectedType("uint8_t");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("42U");
+    });
+
+    it("should handle uint32_t C type as unsigned", () => {
+      const node = createMockLiteral("0x80000000");
+      const state = createStateWithExpectedType("uint32_t");
+      const result = generateLiteral(node, mockInput, state, mockOrchestrator);
+
+      expect(result.code).toBe("0x80000000U");
+    });
+  });
 });

package/src/transpiler/output/codegen/helpers/AssignmentExpectedTypeResolver.ts

@@ -116,17 +116,18 @@ class AssignmentExpectedTypeResolver {
     let currentStructType: string | undefined = rootTypeInfo.baseType;
 
     // Walk through each member in the chain to find the final field's type
+    // Issue #831: Use SymbolTable as single source of truth for struct fields
     for (let i = 1; i < identifiers.length && currentStructType; i++) {
       const memberName = identifiers[i];
-      const structFieldTypes: ReadonlyMap<string, string> | undefined =
-        CodeGenState.symbols?.structFields.get(currentStructType);
+      const memberType = CodeGenState.symbolTable?.getStructFieldType(
+        currentStructType,
+        memberName,
+      );
 
-      if (!structFieldTypes?.has(memberName)) {
+      if (!memberType) {
         break;
       }
 
-      const memberType: string = structFieldTypes.get(memberName)!;
-
       if (i === identifiers.length - 1) {
         // Last field in chain - this is the assignment target's type
         return { expectedType: memberType, assignmentContext: null };

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

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach } from "vitest";
 import AssignmentExpectedTypeResolver from "../AssignmentExpectedTypeResolver.js";
 import CNextSourceParser from "../../../../logic/parser/CNextSourceParser.js";
 import CodeGenState from "../../../../state/CodeGenState.js";
+import SymbolTable from "../../../../logic/symbols/SymbolTable.js";
 
 /**
  * Create a mock assignment target context by parsing a minimal assignment statement.
@@ -18,12 +19,24 @@ function parseAssignmentTarget(target: string) {
 }
 
 /**
- * Helper to set up struct fields in CodeGenState.symbols
+ * Helper to set up struct fields in CodeGenState.symbolTable
+ * Issue #831: SymbolTable is now the single source of truth for struct fields
  */
 function setupStructFields(
   structName: string,
   fields: Map<string, string>,
 ): void {
+  // Initialize symbolTable if not set
+  if (!CodeGenState.symbolTable) {
+    CodeGenState.symbolTable = new SymbolTable();
+  }
+
+  // Register struct fields in SymbolTable
+  for (const [fieldName, fieldType] of fields) {
+    CodeGenState.symbolTable.addStructField(structName, fieldName, fieldType);
+  }
+
+  // Also mark struct as known (for isKnownStruct checks)
   if (!CodeGenState.symbols) {
     CodeGenState.symbols = {
       knownStructs: new Set(),
@@ -54,10 +67,6 @@ function setupStructFields(
     };
   }
   (CodeGenState.symbols.knownStructs as Set<string>).add(structName);
-  (CodeGenState.symbols.structFields as Map<string, Map<string, string>>).set(
-    structName,
-    fields,
-  );
 }
 
 describe("AssignmentExpectedTypeResolver", () => {

package/src/transpiler/types/IFileSystem.ts

@@ -58,6 +58,14 @@ interface IFileSystem {
    * @throws Error if file doesn't exist or can't be read
    */
   stat(path: string): { mtimeMs: number };
+
+  /**
+   * Resolve symlinks to get the real path.
+   * Optional - if not provided, symlink loop detection is skipped.
+   * @returns The resolved real path
+   * @throws Error if path doesn't exist
+   */
+  realpath?(path: string): string;
 }
 
 export default IFileSystem;