c-next 0.2.8 → 0.2.10

package/src/transpiler/output/codegen/generators/declarationGenerators/__tests__/ScopeGenerator.test.ts

@@ -466,6 +466,9 @@ function createMockOrchestrator(
     generateCallbackTypedef: vi.fn(() => null),
     isConstValue: vi.fn(() => true),
     tryEvaluateConstant: vi.fn(() => undefined),
+    // Issue #948: Opaque type helpers
+    isOpaqueType: vi.fn(() => false),
+    markOpaqueScopeVariable: vi.fn(),
     ...overrides,
   } as unknown as IOrchestrator;
 }
@@ -721,6 +724,52 @@ describe("ScopeGenerator", () => {
       expect(result.code).toContain("static uint32_t Device_status = 0;");
       expect(orchestrator.getZeroInitializer).toHaveBeenCalled();
     });
+
+    it("generates opaque type variable as pointer with NULL (Issue #948)", () => {
+      const varDecl = createMockVariableDecl({
+        name: "widget",
+        type: "widget_t",
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("GUI", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        ...createMockOrchestrator(),
+        isOpaqueType: vi.fn(() => true),
+        markOpaqueScopeVariable: vi.fn(),
+      });
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      // Should generate as pointer with NULL initialization
+      expect(result.code).toContain("static widget_t* GUI_widget = NULL;");
+      // Should call markOpaqueScopeVariable
+      expect(orchestrator.markOpaqueScopeVariable).toHaveBeenCalledWith(
+        "GUI_widget",
+      );
+    });
+
+    it("does not generate pointer for non-opaque struct types", () => {
+      const varDecl = createMockVariableDecl({
+        name: "point",
+        type: "Point",
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("Canvas", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        ...createMockOrchestrator(),
+        isOpaqueType: vi.fn(() => false),
+      });
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      // Should generate as value with {0} initialization
+      expect(result.code).toContain("static Point Canvas_point = 0;");
+      expect(result.code).not.toContain("Point*");
+    });
   });
 
   // ========================================================================

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

@@ -13,6 +13,8 @@
  */
 import IGeneratorOutput from "../IGeneratorOutput";
 import TTypeInfo from "../../types/TTypeInfo";
+import CodeGenState from "../../../../state/CodeGenState.js";
+import NarrowingCastHelper from "../../helpers/NarrowingCastHelper.js";
 
 /**
  * Generate code for .capacity property access.
@@ -56,22 +58,32 @@ interface BitmapFieldInfo {
  *
  * Single bit fields generate: ((value >> offset) & 1)
  * Multi-bit fields generate: ((value >> offset) & mask)
+ *
+ * MISRA C:2012 Rule 10.3: When target type is known (via CodeGenState.expectedType),
+ * wraps expression with appropriate cast. Bool targets use != 0U comparison.
  */
 const generateBitmapFieldAccess = (
   result: string,
   fieldInfo: BitmapFieldInfo,
 ): IGeneratorOutput => {
+  let expr: string;
   if (fieldInfo.width === 1) {
     // Single bit: ((value >> offset) & 1)
-    return { code: `((${result} >> ${fieldInfo.offset}) & 1)`, effects: [] };
+    expr = `((${result} >> ${fieldInfo.offset}) & 1)`;
   } else {
     // Multi-bit: ((value >> offset) & mask)
     const mask = (1 << fieldInfo.width) - 1;
-    return {
-      code: `((${result} >> ${fieldInfo.offset}) & 0x${mask.toString(16).toUpperCase()})`,
-      effects: [],
-    };
+    expr = `((${result} >> ${fieldInfo.offset}) & 0x${mask.toString(16).toUpperCase()})`;
+  }
+
+  // MISRA 10.3: Add narrowing cast if target type is known
+  const targetType = CodeGenState.expectedType;
+  if (targetType) {
+    // Bitmap operations on small types produce int in C
+    expr = NarrowingCastHelper.wrap(expr, "int", targetType);
   }
+
+  return { code: expr, effects: [] };
 };
 
 // Export all generators

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

@@ -107,6 +107,7 @@ const _parameterExpectsAddressOf = (
 /**
  * Generate argument code for a C/C++ function call.
  * Handles automatic address-of (&) for struct arguments passed to pointer params.
+ * Issue #872: Sets expectedType for MISRA 7.2 U suffix on unsigned literals.
  */
 const _generateCFunctionArg = (
   e: ExpressionContext,
@@ -134,7 +135,13 @@ const _generateCFunctionArg = (
     );
   }
 
-  let argCode = orchestrator.generateExpression(e);
+  // Issue #872: Set expectedType for MISRA 7.2 compliance, but suppress bare enum resolution
+  // (bare enums in function args was never allowed - changing that requires ADR approval)
+  const argCode = CodeGenState.withExpectedType(
+    targetParam?.baseType,
+    () => orchestrator.generateExpression(e),
+    true, // suppressEnumResolution
+  );
 
   // Issue #322: Check if parameter expects a pointer and argument is a struct
   if (!targetParam?.baseType?.endsWith("*")) {
@@ -158,24 +165,32 @@ const _generateCFunctionArg = (
     isPointerVariable = true;
   }
 
+  // Issue #948: Check if argument is an opaque scope variable (already a pointer)
+  const isOpaqueScopeVar = CodeGenState.isOpaqueScopeVariable(argCode);
+
   // 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*).
   // Issue #895 Bug B: Skip address-of for variables that are already pointers
+  // Issue #948: Skip address-of for opaque scope variables (already pointers)
   const needsAddressOf =
     argType &&
     !argType.endsWith("*") &&
     !argCode.startsWith("&") &&
     !targetParam.isArray &&
     !isPointerVariable &&
+    !isOpaqueScopeVar &&
     (orchestrator.isStructType(argType) ||
       _parameterExpectsAddressOf(targetParam.baseType, argType, orchestrator));
 
-  if (needsAddressOf) {
-    argCode = `&${argCode}`;
-  }
+  const finalArgCode = needsAddressOf ? `&${argCode}` : argCode;
 
-  return wrapWithCppEnumCast(argCode, e, targetParam?.baseType, orchestrator);
+  return wrapWithCppEnumCast(
+    finalArgCode,
+    e,
+    targetParam?.baseType,
+    orchestrator,
+  );
 };
 
 /**
@@ -295,7 +310,12 @@ const generateFunctionCall = (
           orchestrator,
         )
       ) {
-        const argCode = orchestrator.generateExpression(e);
+        // Issue #872: Set expectedType for MISRA 7.2 compliance, but suppress bare enum resolution
+        const argCode = CodeGenState.withExpectedType(
+          targetParam?.baseType,
+          () => orchestrator.generateExpression(e),
+          true, // suppressEnumResolution
+        );
         return wrapWithCppEnumCast(
           argCode,
           e,

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

@@ -14,6 +14,8 @@ import TGeneratorEffect from "../TGeneratorEffect";
 import IGeneratorInput from "../IGeneratorInput";
 import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
+import NarrowingCastHelper from "../../helpers/NarrowingCastHelper.js";
+import CodeGenState from "../../../../state/CodeGenState";
 
 /**
  * Unsigned type patterns for MISRA Rule 7.2 compliance.
@@ -27,8 +29,18 @@ const UNSIGNED_TYPES = new Set([
   "uint8_t",
   "uint16_t",
   "uint32_t",
+  "size_t", // Array indices (MISRA 7.2)
 ]);
 
+/**
+ * Resolve typedef aliases to their underlying type.
+ * For C typedef'd types (e.g., "byte_t" -> "uint8_t"), look up the symbol table.
+ */
+function resolveTypedef(typeName: string): string {
+  const underlyingType = CodeGenState.getTypedefType(typeName);
+  return underlyingType ?? typeName;
+}
+
 /**
  * Check if a literal is a numeric integer (decimal, hex, octal, or binary).
  * Excludes strings, floats, and booleans.
@@ -83,6 +95,21 @@ const generateLiteral = (
     return { code: literalText, effects };
   }
 
+  // MISRA 10.3: Character literals have type int in C
+  // When assigning to narrower types (u8, i8, u16, i16), add explicit cast
+  if (literalText.startsWith("'")) {
+    const expectedType = state?.expectedType;
+    if (expectedType) {
+      const wrappedCode = NarrowingCastHelper.wrap(
+        literalText,
+        "int",
+        expectedType,
+      );
+      return { code: wrappedCode, effects };
+    }
+    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)
@@ -120,9 +147,11 @@ const generateLiteral = (
     isNumericIntegerLiteral(literalText) &&
     !hasUnsignedSuffix(literalText)
   ) {
-    if (UNSIGNED_64_TYPES.has(expectedType)) {
+    // Resolve typedef aliases (e.g., "byte_t" -> "uint8_t")
+    const resolvedType = resolveTypedef(expectedType);
+    if (UNSIGNED_64_TYPES.has(resolvedType)) {
       literalText = literalText + "ULL";
-    } else if (UNSIGNED_TYPES.has(expectedType)) {
+    } else if (UNSIGNED_TYPES.has(resolvedType)) {
       literalText = literalText + "U";
     }
   }

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

@@ -22,6 +22,7 @@ import generateFunctionCall from "./CallExprGenerator";
 import memberAccessChain from "../../memberAccessChain";
 import MemberAccessValidator from "../../helpers/MemberAccessValidator";
 import BitmapAccessHelper from "./BitmapAccessHelper";
+import NarrowingCastHelper from "../../helpers/NarrowingCastHelper";
 import TypeCheckUtils from "../../../../../utils/TypeCheckUtils";
 import SubscriptClassifier from "../../subscript/SubscriptClassifier";
 import TYPE_WIDTH from "../../types/TYPE_WIDTH";
@@ -1593,7 +1594,11 @@ const handleSingleSubscript = (
   orchestrator: IOrchestrator,
   output: SubscriptAccessResult,
 ): SubscriptAccessResult => {
-  const index = orchestrator.generateExpression(expr);
+  // Set expectedType to size_t (unsigned) for array indices per MISRA 7.2
+  // This ensures index literals get U suffix regardless of element type
+  const index = CodeGenState.withExpectedType("size_t", () =>
+    orchestrator.generateExpression(expr),
+  );
 
   // Check if result is a register member with bitmap type (throws)
   validateNotBitmapMember(ctx, input);
@@ -1603,7 +1608,17 @@ const handleSingleSubscript = (
 
   // Register access: bit extraction
   if (isRegisterAccess) {
-    output.result = `((${ctx.result} >> ${index}) & 1)`;
+    // Skip shift when index is 0 (either "0" or "0U" with MISRA suffix)
+    let expr =
+      index === "0" || index === "0U"
+        ? `((${ctx.result}) & 1)`
+        : `((${ctx.result} >> ${index}) & 1)`;
+    // MISRA 10.3: Add narrowing cast if expected type is narrower than int
+    const targetType = CodeGenState.expectedType;
+    if (targetType) {
+      expr = NarrowingCastHelper.wrap(expr, "int", targetType);
+    }
+    output.result = expr;
     return output;
   }
 
@@ -1624,7 +1639,17 @@ const handleSingleSubscript = (
   const isPrimitiveIntMember =
     ctx.currentStructType && TypeCheckUtils.isInteger(ctx.currentStructType);
   if (isPrimitiveIntMember) {
-    output.result = `((${ctx.result} >> ${index}) & 1)`;
+    // Skip shift when index is 0 (either "0" or "0U" with MISRA suffix)
+    let expr =
+      index === "0" || index === "0U"
+        ? `((${ctx.result}) & 1)`
+        : `((${ctx.result} >> ${index}) & 1)`;
+    // MISRA 10.3: Add narrowing cast if expected type is narrower than int
+    const targetType = CodeGenState.expectedType;
+    if (targetType) {
+      expr = NarrowingCastHelper.wrap(expr, "int", targetType);
+    }
+    output.result = expr;
     output.currentStructType = undefined;
     return output;
   }
@@ -1742,10 +1767,21 @@ const handleDefaultSubscript = (
     isRegisterAccess: false,
   });
 
-  output.result =
-    subscriptKind === "bit_single"
-      ? `((${ctx.result} >> ${index}) & 1)`
-      : `${ctx.result}[${index}]`;
+  if (subscriptKind === "bit_single") {
+    // Skip shift when index is 0 (either "0" or "0U" with MISRA suffix)
+    let expr =
+      index === "0" || index === "0U"
+        ? `((${ctx.result}) & 1)`
+        : `((${ctx.result} >> ${index}) & 1)`;
+    // MISRA 10.3: Add narrowing cast if expected type is narrower than int
+    const targetType = CodeGenState.expectedType;
+    if (targetType) {
+      expr = NarrowingCastHelper.wrap(expr, "int", targetType);
+    }
+    output.result = expr;
+  } else {
+    output.result = `${ctx.result}[${index}]`;
+  }
 
   return output;
 };
@@ -1762,8 +1798,12 @@ const handleBitRangeSubscript = (
   effects: TGeneratorEffect[],
   output: SubscriptAccessResult,
 ): SubscriptAccessResult => {
-  const start = orchestrator.generateExpression(exprs[0]);
-  const width = orchestrator.generateExpression(exprs[1]);
+  // Set expectedType to size_t (unsigned) for bit indices per MISRA 7.2
+  // Bit positions are inherently unsigned values
+  const [start, width] = CodeGenState.withExpectedType("size_t", () => [
+    orchestrator.generateExpression(exprs[0]),
+    orchestrator.generateExpression(exprs[1]),
+  ]);
 
   const isFloatType =
     ctx.primaryTypeInfo?.baseType === "f32" ||
@@ -1784,10 +1824,28 @@ const handleBitRangeSubscript = (
     );
   } else {
     const mask = orchestrator.generateBitMask(width);
-    if (start === "0") {
-      output.result = `((${ctx.result}) & ${mask})`;
+    // Skip shift when start is 0 (either "0" or "0U" with MISRA suffix)
+    let expr: string;
+    if (start === "0" || start === "0U") {
+      expr = `((${ctx.result}) & ${mask})`;
+    } else {
+      expr = `((${ctx.result} >> ${start}) & ${mask})`;
+    }
+
+    // MISRA 10.3: Add narrowing cast if expected type is known
+    // Bit operations promote to int, so wrap with cast when assigning to narrower types
+    const targetType = CodeGenState.expectedType;
+    if (targetType && ctx.primaryTypeInfo?.baseType) {
+      const promotedSourceType = NarrowingCastHelper.getPromotedType(
+        ctx.primaryTypeInfo.baseType,
+      );
+      output.result = NarrowingCastHelper.wrap(
+        expr,
+        promotedSourceType,
+        targetType,
+      );
     } else {
-      output.result = `((${ctx.result} >> ${start}) & ${mask})`;
+      output.result = expr;
     }
   }
 
@@ -1854,7 +1912,8 @@ const handleFloatBitRange = (
   }
 
   // Return just the bit read expression using union member .u
-  if (ctx.start === "0") {
+  // Skip shift when start is 0 (either "0" or "0U" with MISRA suffix)
+  if (ctx.start === "0" || ctx.start === "0U") {
     return `(${shadowName}.u & ${mask})`;
   }
   return `((${shadowName}.u >> ${ctx.start}) & ${mask})`;

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

@@ -8,6 +8,7 @@
  */
 import { UnaryExpressionContext } from "../../../../logic/parser/grammar/CNextParser";
 import IGeneratorOutput from "../IGeneratorOutput";
+import TGeneratorEffect from "../TGeneratorEffect";
 import IGeneratorInput from "../IGeneratorInput";
 import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
@@ -15,6 +16,14 @@ import TypeResolver from "../../TypeResolver";
 import TYPE_MAP from "../../types/TYPE_MAP";
 import CppModeHelper from "../../helpers/CppModeHelper";
 
+/**
+ * Problematic negative literals that overflow their signed types in C.
+ * -2147483648 is parsed as -(2147483648) where 2147483648 > INT32_MAX.
+ * These need to be rewritten to avoid the overflow issue.
+ */
+const INT32_MIN_LITERAL = "2147483648";
+const INT64_MIN_LITERAL = "9223372036854775808";
+
 /**
  * Generate C code for a unary expression.
  *
@@ -45,7 +54,22 @@ const generateUnaryExpr = (
 
   // Determine the operator and generate output
   if (text.startsWith("!")) return { code: `!${inner}`, effects: [] };
-  if (text.startsWith("-")) return { code: `-${inner}`, effects: [] };
+  if (text.startsWith("-")) {
+    // MISRA 10.3: Handle problematic negative literals that overflow in C
+    // -2147483648 is parsed as -(2147483648) where 2147483648 > INT32_MAX
+    // Must use INT32_MIN or INT64_MIN to avoid the overflow
+    // Cast is needed because INT32_MIN has type 'int', not 'int32_t'
+    const effects: TGeneratorEffect[] = [];
+    if (inner === INT32_MIN_LITERAL) {
+      effects.push({ type: "include", header: "limits" });
+      return { code: "(int32_t)INT32_MIN", effects };
+    }
+    if (inner === INT64_MIN_LITERAL || inner === INT64_MIN_LITERAL + "LL") {
+      effects.push({ type: "include", header: "limits" });
+      return { code: "(int64_t)INT64_MIN", effects };
+    }
+    return { code: `-${inner}`, effects };
+  }
   if (text.startsWith("~")) {
     const innerType = TypeResolver.getUnaryExpressionType(
       node.unaryExpression()!,

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

@@ -1179,7 +1179,8 @@ describe("PostfixExpressionGenerator", () => {
       });
 
       const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("((GPIO >> 0) & 1)");
+      // Optimization: no shift when index is 0
+      expect(result.code).toBe("((GPIO) & 1)");
     });
 
     it("throws for bracket indexing on bitmap type", () => {

package/src/transpiler/output/codegen/generators/statements/AtomicGenerator.ts

@@ -13,6 +13,7 @@ import IGeneratorOutput from "../IGeneratorOutput";
 import TGeneratorEffect from "../TGeneratorEffect";
 import ITargetCapabilities from "../../types/ITargetCapabilities";
 import TYPE_WIDTH from "../../types/TYPE_WIDTH";
+import COMPOUND_TO_BINARY from "../../types/COMPOUND_TO_BINARY";
 
 /**
  * Maps C-Next types to C types (for atomic operations)
@@ -54,22 +55,6 @@ const STREX_MAP: Record<string, string> = {
   i32: "__STREXW",
 };
 
-/**
- * Map compound operators to simple operators
- */
-const SIMPLE_OP_MAP: Record<string, string> = {
-  "+=": "+",
-  "-=": "-",
-  "*=": "*",
-  "/=": "/",
-  "%=": "%",
-  "&=": "&",
-  "|=": "|",
-  "^=": "^",
-  "<<=": "<<",
-  ">>=": ">>",
-};
-
 /**
  * Map compound operators to clamp helper operation names
  */
@@ -106,7 +91,7 @@ function generateInnerAtomicOp(
   typeInfo: TTypeInfo,
 ): IGeneratorOutput {
   const effects: TGeneratorEffect[] = [];
-  const simpleOp = SIMPLE_OP_MAP[cOp] || "+";
+  const simpleOp = COMPOUND_TO_BINARY[cOp] || "+";
 
   // Handle clamp behavior for arithmetic operations (integers only)
   const helperOp = getClampHelperOp(cOp, typeInfo);

package/src/transpiler/output/codegen/generators/support/IncludeGenerator.ts

@@ -13,6 +13,7 @@ interface IIncludeTransformOptions {
   sourcePath: string | null;
   includeDirs?: string[];
   inputs?: string[];
+  cppMode?: boolean;
 }
 
 /**
@@ -24,6 +25,7 @@ const resolveAngleIncludePath = (
   sourcePath: string,
   includeDirs: string[],
   inputs: string[],
+  cppMode: boolean,
 ): string | null => {
   if (inputs.length === 0) {
     return null;
@@ -42,7 +44,8 @@ const resolveAngleIncludePath = (
     inputs,
   );
 
-  return relativePath ? relativePath.replace(/\.cnx$/, ".h") : null;
+  const ext = cppMode ? ".hpp" : ".h";
+  return relativePath ? relativePath.replace(/\.cnx$/, ext) : null;
 };
 
 /**
@@ -54,7 +57,12 @@ const transformAngleInclude = (
   filename: string,
   options: IIncludeTransformOptions,
 ): string => {
-  const { sourcePath, includeDirs = [], inputs = [] } = options;
+  const {
+    sourcePath,
+    includeDirs = [],
+    inputs = [],
+    cppMode = false,
+  } = options;
 
   // Try to resolve the correct output path
   if (sourcePath) {
@@ -63,6 +71,7 @@ const transformAngleInclude = (
       sourcePath,
       includeDirs,
       inputs,
+      cppMode,
     );
     if (resolvedPath) {
       return includeText.replace(`<${filename}.cnx>`, `<${resolvedPath}>`);
@@ -70,7 +79,8 @@ const transformAngleInclude = (
   }
 
   // Fallback: simple replacement
-  return includeText.replace(`<${filename}.cnx>`, `<${filename}.h>`);
+  const ext = cppMode ? ".hpp" : ".h";
+  return includeText.replace(`<${filename}.cnx>`, `<${filename}${ext}>`);
 };
 
 /**
@@ -82,7 +92,7 @@ const transformQuoteInclude = (
   filepath: string,
   options: IIncludeTransformOptions,
 ): string => {
-  const { sourcePath } = options;
+  const { sourcePath, cppMode = false } = options;
 
   // Validate .cnx file exists if we have source path
   if (sourcePath) {
@@ -98,12 +108,14 @@ const transformQuoteInclude = (
     }
   }
 
-  // Transform to .h
-  return includeText.replace(`"${filepath}.cnx"`, `"${filepath}.h"`);
+  // Transform to .h or .hpp
+  const ext = cppMode ? ".hpp" : ".h";
+  return includeText.replace(`"${filepath}.cnx"`, `"${filepath}${ext}"`);
 };
 
 /**
- * ADR-010: Transform #include directives, converting .cnx to .h
+ * ADR-010: Transform #include directives, converting .cnx to .h or .hpp
+ * Issue #941: Uses .hpp extension when cppMode is true
  * Validates that .cnx files exist if sourcePath is available
  * Supports both <file.cnx> and "file.cnx" forms
  *

package/src/transpiler/output/codegen/generators/support/__tests__/IncludeGenerator.test.ts

@@ -156,6 +156,44 @@ describe("IncludeGenerator", () => {
 
       expect(result).toBe("#include <lib.h>");
     });
+
+    it("transforms angle bracket .cnx include to .hpp in C++ mode", () => {
+      const result = transformIncludeDirective("#include <utils.cnx>", {
+        sourcePath: null,
+        cppMode: true,
+      });
+      expect(result).toBe("#include <utils.hpp>");
+    });
+
+    it("resolves path from inputs with .hpp in C++ mode", () => {
+      vi.mocked(CnxFileResolver.findCnxFile).mockReturnValue(
+        "/project/src/Display/utils.cnx",
+      );
+      vi.mocked(CnxFileResolver.getRelativePathFromInputs).mockReturnValue(
+        "Display/utils.cnx",
+      );
+
+      const result = transformIncludeDirective("#include <utils.cnx>", {
+        sourcePath: "/project/src/main.cnx",
+        includeDirs: ["/project/src/Display"],
+        inputs: ["/project/src"],
+        cppMode: true,
+      });
+
+      expect(result).toBe("#include <Display/utils.hpp>");
+    });
+
+    it("falls back to .hpp in C++ mode when file not found", () => {
+      vi.mocked(CnxFileResolver.findCnxFile).mockReturnValue(null);
+
+      const result = transformIncludeDirective("#include <missing.cnx>", {
+        sourcePath: "/project/src/main.cnx",
+        inputs: ["/project/src"],
+        cppMode: true,
+      });
+
+      expect(result).toBe("#include <missing.hpp>");
+    });
   });
 
   // ==========================================================================
@@ -221,6 +259,28 @@ describe("IncludeGenerator", () => {
         }),
       ).toThrow(/Referenced in:.*main\.cnx/);
     });
+
+    it("transforms quoted .cnx include to .hpp in C++ mode", () => {
+      vi.mocked(CnxFileResolver.cnxFileExists).mockReturnValue(true);
+
+      const result = transformIncludeDirective('#include "helper.cnx"', {
+        sourcePath: "/project/src/main.cnx",
+        cppMode: true,
+      });
+
+      expect(result).toBe('#include "helper.hpp"');
+    });
+
+    it("transforms quoted include with relative path to .hpp in C++ mode", () => {
+      vi.mocked(CnxFileResolver.cnxFileExists).mockReturnValue(true);
+
+      const result = transformIncludeDirective('#include "../lib/utils.cnx"', {
+        sourcePath: "/project/src/main.cnx",
+        cppMode: true,
+      });
+
+      expect(result).toBe('#include "../lib/utils.hpp"');
+    });
   });
 
   // ==========================================================================
@@ -262,6 +322,14 @@ describe("IncludeGenerator", () => {
       });
       expect(result).toBe("int x = 5;");
     });
+
+    it("passes through .h includes unchanged even in C++ mode", () => {
+      const result = transformIncludeDirective('#include "myheader.h"', {
+        sourcePath: "/project/main.cnx",
+        cppMode: true,
+      });
+      expect(result).toBe('#include "myheader.h"');
+    });
   });
 
   // ==========================================================================