c-next 0.2.17 → 0.2.18

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

@@ -155,17 +155,14 @@ const generatePostfixExpression = (
   // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
   const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
 
-  // Issue #579: Check if we have subscript access on a non-array parameter
-  const hasSubscriptOps = ops.some((op) => op.expression().length > 0);
-  const isNonArrayParamWithSubscript =
-    paramInfo && !paramInfo.isArray && !paramInfo.isStruct && hasSubscriptOps;
-
-  let result: string;
-  if (isNonArrayParamWithSubscript) {
-    result = rootIdentifier!;
-  } else {
-    result = orchestrator.generatePrimaryExpr(primary);
-  }
+  // Issue #1100: Subscripted parameters resolve through the normal primary
+  // expression path (ParameterDereferenceResolver), same as any other
+  // parameter reference. This is a no-op for array/struct/string params
+  // (already pointer-like, so `buf[idx]` is unaffected), and correctly
+  // dereferences a scalar parameter that became a pointer because it's
+  // modified elsewhere in the function, so bit access (`v[4]`) reads
+  // through the pointer instead of pointer-indexing past it.
+  const result: string = orchestrator.generatePrimaryExpr(primary);
 
   const primaryTypeInfo = rootIdentifier
     ? CodeGenState.getVariableTypeInfo(rootIdentifier)
@@ -1805,6 +1802,14 @@ const handleBitRangeSubscript = (
     orchestrator.generateExpression(exprs[1]),
   ]);
 
+  // Issue #1094: resolve a const/macro width to its numeric value so the mask is
+  // precomputed (byte-identical to a literal width) instead of a runtime
+  // ((1U << W) - 1) — which is UB at full width (1U << 32) and uses the wrong
+  // base type for >32-bit widths. The "U" suffix matches the literal path, which
+  // generates bit widths under a size_t expectedType.
+  const widthConst = orchestrator.tryEvaluateConstant(exprs[1]);
+  const maskWidth = widthConst === undefined ? width : `${widthConst}U`;
+
   const isFloatType =
     ctx.primaryTypeInfo?.baseType === "f32" ||
     ctx.primaryTypeInfo?.baseType === "f64";
@@ -1817,13 +1822,19 @@ const handleBitRangeSubscript = (
         baseType: ctx.primaryTypeInfo!.baseType,
         start,
         width,
+        maskWidth,
       },
       state,
       orchestrator,
       effects,
     );
   } else {
-    const mask = orchestrator.generateBitMask(width);
+    // Issue #1094: 64-bit operands need a 64-bit mask base (1ULL / wide hex) so
+    // widths > 32 don't shift past a 32-bit literal's width.
+    const is64BitOperand =
+      ctx.primaryTypeInfo?.baseType === "u64" ||
+      ctx.primaryTypeInfo?.baseType === "i64";
+    const mask = orchestrator.generateBitMask(maskWidth, is64BitOperand);
     // Skip shift when start is 0 (either "0" or "0U" with MISRA suffix)
     let expr: string;
     if (start === "0" || start === "0U") {
@@ -1861,6 +1872,8 @@ interface IFloatBitRangeContext {
   baseType: string;
   start: string;
   width: string;
+  /** Width formatted for mask generation (const-resolved when possible, #1094). */
+  maskWidth: string;
 }
 
 /**
@@ -1892,7 +1905,7 @@ const handleFloatBitRange = (
   const floatType = getFloatTypeName(ctx.baseType);
   const intType = isF64 ? "uint64_t" : "uint32_t";
   const shadowName = `__bits_${ctx.rootIdentifier}`;
-  const mask = orchestrator.generateBitMask(ctx.width, isF64);
+  const mask = orchestrator.generateBitMask(ctx.maskWidth, isF64);
 
   const needsDeclaration = !orchestrator.hasFloatBitShadow(shadowName);
   if (needsDeclaration) {

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

@@ -147,6 +147,7 @@ function createMockOrchestrator(overrides?: {
   ) => TTypeInfo | null;
   validateCrossScopeVisibility?: (scope: string, member: string) => void;
   generateBitMask?: (width: string, is64?: boolean) => string;
+  tryEvaluateConstant?: (ctx: unknown) => number | undefined;
   hasFloatBitShadow?: (name: string) => boolean;
   registerFloatBitShadow?: (name: string) => void;
   addPendingTempDeclaration?: (decl: string) => void;
@@ -172,7 +173,7 @@ function createMockOrchestrator(overrides?: {
     isCNextFunction: vi.fn(),
     isStructType: vi.fn(),
     getTypeName: vi.fn(),
-    tryEvaluateConstant: vi.fn(),
+    tryEvaluateConstant: overrides?.tryEvaluateConstant ?? vi.fn(),
     getZeroInitializer: vi.fn(),
     getExpressionEnumType: vi.fn(),
     isIntegerExpression: vi.fn(),
@@ -1265,6 +1266,98 @@ describe("PostfixExpressionGenerator", () => {
       const result = generatePostfixExpression(ctx, input, state, orchestrator);
       expect(result.code).toBe("((val) & 0xFF)");
     });
+
+    // Issue #1094: a const/macro width must be resolved to its numeric value (with
+    // a "U" suffix to match the literal path) before mask generation, instead of
+    // being passed through as the identifier — otherwise the mask falls back to a
+    // runtime ((1U << W) - 1) that is UB at full width.
+    it("resolves a const width to a precomputed mask (#1094)", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "val",
+          { baseType: "u32", bitWidth: 32, isArray: false, isConst: false },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({
+          expressions: [
+            createMockExpression("0"),
+            createMockExpression("WIDTH"),
+          ],
+        }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const generateBitMask = vi.fn(() => "0xFFFFFFFFU");
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+        generateExpression: (ctx) => ctx.getText(),
+        generateBitMask,
+        tryEvaluateConstant: () => 32,
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      // Width resolved to "32U" (not the identifier "WIDTH"); u32 operand → not 64-bit.
+      expect(generateBitMask).toHaveBeenCalledWith("32U", false);
+      expect(result.code).toBe("((val) & 0xFFFFFFFFU)");
+    });
+
+    it("passes the raw width when it is not a const (#1094)", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "val",
+          { baseType: "u32", bitWidth: 32, isArray: false, isConst: false },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({
+          expressions: [createMockExpression("0"), createMockExpression("n")],
+        }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const generateBitMask = vi.fn(() => "((1U << n) - 1)");
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+        generateExpression: (ctx) => ctx.getText(),
+        generateBitMask,
+        tryEvaluateConstant: () => undefined,
+      });
+
+      generatePostfixExpression(ctx, input, state, orchestrator);
+      // Non-const width: the generated expression string flows through unchanged.
+      expect(generateBitMask).toHaveBeenCalledWith("n", false);
+    });
+
+    it("marks a u64 operand as 64-bit for the mask base (#1094)", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "val",
+          { baseType: "u64", bitWidth: 64, isArray: false, isConst: false },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({
+          expressions: [
+            createMockExpression("0"),
+            createMockExpression("WIDTH"),
+          ],
+        }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const generateBitMask = vi.fn(() => "((1ULL << 40U) - 1)");
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+        generateExpression: (ctx) => ctx.getText(),
+        generateBitMask,
+        tryEvaluateConstant: () => 40,
+      });
+
+      generatePostfixExpression(ctx, input, state, orchestrator);
+      // u64 operand → is64Bit true, so the mask uses a 64-bit base (1ULL).
+      expect(generateBitMask).toHaveBeenCalledWith("40U", true);
+    });
   });
 
   describe("float bit indexing", () => {
@@ -1371,6 +1464,41 @@ describe("PostfixExpressionGenerator", () => {
       // Uses union member .u for bit access
       expect(result.code).toBe("(__bits_f.u & 0xFF)");
     });
+
+    // Issue #1094: the float branch must resolve a const width too, and tell the
+    // mask generator the f64 union is 64-bit.
+    it("resolves a const width for f64 bit indexing (#1094)", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "d",
+          { baseType: "f64", bitWidth: 64, isArray: false, isConst: false },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("d", [
+        createMockPostfixOp({
+          expressions: [
+            createMockExpression("0"),
+            createMockExpression("WIDTH"),
+          ],
+        }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState({ inFunctionBody: true });
+      const generateBitMask = vi.fn(() => "0xFFFFFFFFFFFFFFFFULL");
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "d",
+        generateExpression: (ctx) => ctx.getText(),
+        generateBitMask,
+        tryEvaluateConstant: () => 64,
+        hasFloatBitShadow: () => true,
+        isFloatShadowCurrent: () => true,
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      // Const width "64U" passed; f64 union → 64-bit mask base.
+      expect(generateBitMask).toHaveBeenCalledWith("64U", true);
+      expect(result.code).toBe("(__bits_d.u & 0xFFFFFFFFFFFFFFFFULL)");
+    });
   });
 
   describe("function call", () => {

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

@@ -14,6 +14,7 @@ import {
   WhileStatementContext,
   DoWhileStatementContext,
   ForStatementContext,
+  ForeverStatementContext,
   ForVarDeclContext,
   ForAssignmentContext,
   ExpressionContext,
@@ -167,6 +168,9 @@ const generateWhile = (
   // Issue #884: Validate condition is a boolean expression (E0701)
   orchestrator.validateConditionIsBoolean(node.expression(), "while");
 
+  // ADR-113 / #1075: reject always-true literal condition (E0707)
+  orchestrator.validateLoopConditionNotAlwaysTrue(node.expression());
+
   const condition = orchestrator.generateExpression(node.expression());
 
   // Issue #250: Flush any temp vars from condition BEFORE generating body
@@ -201,6 +205,9 @@ const generateDoWhile = (
   // Issue #884: Validate condition is a boolean expression (E0701)
   orchestrator.validateConditionIsBoolean(node.expression(), "do-while");
 
+  // ADR-113 / #1075: reject always-true literal condition (E0707)
+  orchestrator.validateLoopConditionNotAlwaysTrue(node.expression());
+
   const body = orchestrator.generateBlock(node.block());
   const condition = orchestrator.generateExpression(node.expression());
 
@@ -286,6 +293,15 @@ const generateFor = (
 ): IGeneratorOutput => {
   const effects: TGeneratorEffect[] = [];
 
+  // ADR-113 / #1075 E0707: a for-loop with no controlling expression (`for (;;)`)
+  // is a disguised infinite loop. C-Next has one source form for that — `forever`.
+  if (!node.expression()) {
+    throw new Error(
+      "Error E0707: for-loop has no controlling expression (infinite loop)\n" +
+        "  help: write 'forever { ... }' for an intentional infinite loop",
+    );
+  }
+
   let init = "";
   const forInit = node.forInit();
   if (forInit) {
@@ -313,15 +329,20 @@ const generateFor = (
   // Issue #250: Flush temps from init before generating condition
   const initTemps = orchestrator.flushPendingTempDeclarations();
 
-  let condition = "";
-  if (node.expression()) {
-    // Issue #254: Validate no function calls in condition (E0702)
-    orchestrator.validateConditionNoFunctionCall(node.expression()!, "for");
+  // The empty-header case (`for (;;)`) already threw E0707 above, so the
+  // controlling expression is guaranteed present here.
+  const conditionExpr = node.expression()!;
 
-    // Issue #884: Validate condition is a boolean expression (E0701)
-    orchestrator.validateConditionIsBoolean(node.expression()!, "for");
-    condition = orchestrator.generateExpression(node.expression()!);
-  }
+  // Issue #254: Validate no function calls in condition (E0702)
+  orchestrator.validateConditionNoFunctionCall(conditionExpr, "for");
+
+  // Issue #884: Validate condition is a boolean expression (E0701)
+  orchestrator.validateConditionIsBoolean(conditionExpr, "for");
+
+  // ADR-113 / #1075: reject always-true literal condition (E0707)
+  orchestrator.validateLoopConditionNotAlwaysTrue(conditionExpr);
+
+  const condition = orchestrator.generateExpression(conditionExpr);
 
   // Issue #250: Flush temps from condition before generating update
   const conditionTemps = orchestrator.flushPendingTempDeclarations();
@@ -357,6 +378,40 @@ const generateFor = (
   return { code: result, effects };
 };
 
+/**
+ * Generate C code for a forever statement (ADR-113).
+ *
+ * Lowers to the MISRA C:2012 Rule 14.3-compliant infinite-loop idiom `for (;;)`
+ * (the carve-out that rule explicitly permits — no controlling expression to be
+ * flagged as invariant). A `forever` loop may appear only in a void function
+ * (E0705): a value-returning function can never honor its return type if it
+ * loops forever.
+ */
+const generateForever = (
+  node: ForeverStatementContext,
+  _input: IGeneratorInput,
+  _state: IGeneratorState,
+  orchestrator: IOrchestrator,
+): IGeneratorOutput => {
+  const effects: TGeneratorEffect[] = [];
+
+  // ADR-113 E0705: forever is void-only.
+  const returnType = orchestrator.getCurrentFunctionReturnType();
+  if (returnType && returnType !== "void") {
+    throw new Error(
+      "Error E0705: forever loop in non-void function\n" +
+        "  help: a forever loop never returns a value; make the function return void, " +
+        "or use a while loop with an exit condition",
+    );
+  }
+
+  const body = orchestrator.generateBlock(node.block());
+  const comment =
+    "/* MISRA C:2012 Rule 14.3: infinite loop is intentional (C-Next `forever`) */";
+
+  return { code: `${comment}\nfor (;;) ${body}`, effects };
+};
+
 // Export all control flow generators
 const controlFlowGenerators = {
   generateReturn,
@@ -364,6 +419,7 @@ const controlFlowGenerators = {
   generateWhile,
   generateDoWhile,
   generateFor,
+  generateForever,
   generateForVarDecl,
   generateForAssignment,
 };

package/src/transpiler/output/codegen/generators/statements/__tests__/ControlFlowGenerator.test.ts

@@ -365,6 +365,7 @@ function createMockOrchestrator(options?: {
     flushPendingTempDeclarations: vi.fn(() => options?.tempDeclarations ?? ""),
     validateConditionNoFunctionCall: vi.fn(),
     validateConditionIsBoolean: vi.fn(),
+    validateLoopConditionNotAlwaysTrue: vi.fn(),
     countStringLengthAccesses: vi.fn(() => new Map()),
     countBlockLengthAccesses: vi.fn(),
     setupLengthCache: vi.fn(() => options?.lengthCacheDecls ?? ""),
@@ -898,15 +899,15 @@ describe("ControlFlowGenerator", () => {
   // ========================================================================
 
   describe("generateFor", () => {
-    it("generates empty for loop (infinite loop)", () => {
-      const ctx = createMockForStatement();
+    it("rejects an empty for(;;) header as a disguised infinite loop (ADR-113 / #1075, E0707)", () => {
+      const ctx = createMockForStatement(); // no controlling expression
       const input = createMockInput();
       const state = createMockState();
       const orchestrator = createMockOrchestrator({ statementCode: "{ }" });
 
-      const result = generateFor(ctx, input, state, orchestrator);
-
-      expect(result.code).toBe("for (; ; ) { }");
+      expect(() => generateFor(ctx, input, state, orchestrator)).toThrow(
+        /E0707: for-loop has no controlling expression/,
+      );
     });
 
     it("generates for loop with all parts", () => {
@@ -947,6 +948,7 @@ describe("ControlFlowGenerator", () => {
             operator: createMockAssignmentOperator("<-"),
           }),
         }),
+        expr: createMockExpression({ text: "i < 10" }),
       });
       const input = createMockInput();
       const state = createMockState();
@@ -1007,6 +1009,7 @@ describe("ControlFlowGenerator", () => {
         init: createMockForInit({
           varDecl: createMockForVarDecl(),
         }),
+        expr: createMockExpression({ text: "i < 10" }),
       });
       const input = createMockInput();
       const state = createMockState();

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

@@ -71,7 +71,10 @@ class AssignmentExpectedTypeResolver {
       // Case 2b: Simple array element access (arr[i] <- value)
       // Issue #872: Resolve element type for MISRA 7.2 U suffix
       if (identifiers.length === 1 && hasSubscript) {
-        return AssignmentExpectedTypeResolver.resolveForArrayElement(baseId);
+        return AssignmentExpectedTypeResolver.resolveForArrayElement(
+          baseId,
+          postfixOps,
+        );
       }
 
       // Case 2c: Member chain with array access (struct.arr[i] <- value)
@@ -87,6 +90,17 @@ class AssignmentExpectedTypeResolver {
     return { expectedType: null, assignmentContext: null };
   }
 
+  /**
+   * True if any postfix subscript is the 2-expression `[offset, length]` form —
+   * an array slice or scalar bit-range write (vs a 1-expression element/bit
+   * access). The grammar models both as `'[' expression ',' expression ']'`.
+   */
+  private static hasRangeSubscript(
+    postfixOps: Parser.PostfixTargetOpContext[],
+  ): boolean {
+    return postfixOps.some((op) => op.expression().length === 2);
+  }
+
   /**
    * Resolve expected type for a simple identifier target.
    */
@@ -124,13 +138,27 @@ class AssignmentExpectedTypeResolver {
   /**
    * Resolve expected type for array element access.
    * Issue #872: arr[i] <- value needs baseType for MISRA 7.2 U suffix.
+   *
+   * An array SLICE (2-expression subscript `arr[off, len]`) is the exception:
+   * its source serializes at the SOURCE's own width, so leaking the element type
+   * as expectedType truncates an element-width-sensitive source such as a
+   * bit-extraction (Issue #1085: `buf[0,4] <- b[0,32]` wrote only the low byte).
+   * This applies only to arrays — a 2-expression subscript on a scalar is a
+   * bit-range write, whose value is genuinely the field's type (unchanged).
    */
-  private static resolveForArrayElement(id: string): IExpectedTypeResult {
+  private static resolveForArrayElement(
+    id: string,
+    postfixOps: Parser.PostfixTargetOpContext[],
+  ): IExpectedTypeResult {
     const typeInfo = CodeGenState.getVariableTypeInfo(id);
     if (!typeInfo?.isArray) {
       return { expectedType: null, assignmentContext: null };
     }
 
+    if (AssignmentExpectedTypeResolver.hasRangeSubscript(postfixOps)) {
+      return { expectedType: null, assignmentContext: null };
+    }
+
     // Element type is the baseType (e.g., u8[10] -> "u8")
     return { expectedType: typeInfo.baseType, assignmentContext: null };
   }

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

@@ -13,7 +13,6 @@
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
-import FormatUtils from "../../../../utils/FormatUtils.js";
 import StringUtils from "../../../../utils/StringUtils.js";
 import CodeGenState from "../../../state/CodeGenState.js";
 
@@ -412,7 +411,10 @@ class StringDeclHelper {
       return { code, handled: true };
     }
 
-    // String variable: need strcpy (cannot use array initialization in C)
+    // String variable: cannot use C array initialization, so declare empty and
+    // copy. Issue #1044: use the same bounded copy as the reassignment path
+    // (strncpy + explicit null terminator via StringUtils.copyWithNull) rather
+    // than an unbounded strcpy, which flawfinder flags as CWE-120.
     // Issue #1030: string-to-string initialization
     if (!CodeGenState.inFunctionBody) {
       throw new Error(
@@ -422,11 +424,12 @@ class StringDeclHelper {
     }
 
     const srcExpr = callbacks.generateExpression(expression);
-    const indent = FormatUtils.indent(CodeGenState.indentLevel);
+    // Issue #1037: continuation lines carry no indent of their own — the block
+    // emitter (CodeGenerator.generateBlock) prefixes every line.
     const lines: string[] = [];
     lines.push(
       `${constMod}char ${name}[${capacity + 1}] = "";`,
-      `${indent}strcpy(${name}, ${srcExpr});`,
+      StringUtils.copyWithNull(name, srcExpr, capacity),
     );
     return { code: lines.join("\n"), handled: true };
   }
@@ -637,14 +640,14 @@ class StringDeclHelper {
       );
     }
 
-    // Generate safe concatenation code
-    const indent = FormatUtils.indent(CodeGenState.indentLevel);
+    // Generate safe concatenation code. Issue #1037: continuation lines carry
+    // no indent of their own — the block emitter prefixes every line.
     const lines: string[] = [];
     lines.push(
       `${constMod}char ${name}[${capacity + 1}] = "";`,
-      `${indent}strncpy(${name}, ${concatOps.left}, ${capacity});`,
-      `${indent}strncat(${name}, ${concatOps.right}, ${capacity} - strlen(${name}));`,
-      `${indent}${name}[${capacity}] = ${C_NULL_CHAR};`,
+      `strncpy(${name}, ${concatOps.left}, ${capacity});`,
+      `strncat(${name}, ${concatOps.right}, ${capacity} - strlen(${name}));`,
+      `${name}[${capacity}] = ${C_NULL_CHAR};`,
     );
     return { code: lines.join("\n"), handled: true };
   }
@@ -688,13 +691,13 @@ class StringDeclHelper {
       );
     }
 
-    // Generate safe substring extraction code
-    const indent = FormatUtils.indent(CodeGenState.indentLevel);
+    // Generate safe substring extraction code. Issue #1037: continuation lines
+    // carry no indent of their own — the block emitter prefixes every line.
     const lines: string[] = [];
     lines.push(
       `${constMod}char ${name}[${capacity + 1}] = "";`,
-      `${indent}strncpy(${name}, ${substringOps.source} + ${substringOps.start}, ${substringOps.length});`,
-      `${indent}${name}[${substringOps.length}] = ${C_NULL_CHAR};`,
+      `strncpy(${name}, ${substringOps.source} + ${substringOps.start}, ${substringOps.length});`,
+      `${name}[${substringOps.length}] = ${C_NULL_CHAR};`,
     );
     return { code: lines.join("\n"), handled: true };
   }

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

@@ -256,6 +256,25 @@ describe("AssignmentExpectedTypeResolver", () => {
 
         expect(result.expectedType).toBeNull();
       });
+
+      // Issue #1085: an array SLICE (2-expression subscript `arr[off, len]`)
+      // serializes the source at the SOURCE's own width. Leaking the element type
+      // as expectedType truncates a wider source (e.g. a bit-extraction), so the
+      // resolver must return null for the slice form — unlike a 1-expression
+      // element access, which keeps the element type for the MISRA 7.2 U suffix.
+      it("should return null for an array slice (2-expression subscript)", () => {
+        CodeGenState.setVariableTypeInfo("buffer", {
+          baseType: "u8",
+          bitWidth: 8,
+          isArray: true,
+          isConst: false,
+        });
+        const target = parseAssignmentTarget("buffer[0, 4]");
+
+        const result = AssignmentExpectedTypeResolver.resolve(target);
+
+        expect(result.expectedType).toBeNull();
+      });
     });
   });
 });

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

@@ -310,7 +310,8 @@ describe("StringDeclHelper", () => {
     });
 
     it("allows assignment when source capacity fits", () => {
-      // Issue #1030: String variable initialization now uses strcpy
+      // Issue #1044: String variable initialization uses a bounded strncpy
+      // (shared with the reassignment path), not an unsafe strcpy (CWE-120).
       const callbacks = {
         ...defaultCallbacks,
         getStringExprCapacity: vi.fn(() => 20),
@@ -338,9 +339,49 @@ describe("StringDeclHelper", () => {
       );
 
       expect(result.handled).toBe(true);
-      // Issue #1030: String variable initialization uses strcpy
+      // Issue #1044: bounded copy, not strcpy
       expect(result.code).toContain('char dest[33] = "";');
-      expect(result.code).toContain("strcpy(dest, smallString)");
+      expect(result.code).toContain("strncpy(dest, smallString, 32);");
+      expect(result.code).toContain("dest[32] = '\\0';");
+      expect(result.code).not.toContain("strcpy(dest, smallString)");
+    });
+
+    it("does not indent continuation lines (the block emitter owns indentation) — Issue #1037", () => {
+      // indentLevel = 1 (beforeEach). generateBlock prefixes every line of a
+      // statement, so the helper must NOT add its own indent or continuation
+      // lines double-indent.
+      const callbacks = {
+        ...defaultCallbacks,
+        getStringExprCapacity: vi.fn(() => 20),
+        generateExpression: vi.fn(() => "smallString"),
+      };
+
+      const typeCtx = {
+        stringType: () => ({
+          INTEGER_LITERAL: () => ({ getText: () => "32" }),
+        }),
+      } as never;
+
+      const expression = {
+        getText: () => "smallString",
+      } as never;
+
+      const result = StringDeclHelper.generateStringDecl(
+        typeCtx,
+        "dest",
+        expression,
+        [],
+        { extern: "", const: "", atomic: "", volatile: "" },
+        false,
+        callbacks,
+      );
+
+      const lines = result.code.split("\n");
+      expect(lines[0]).toBe('char dest[33] = "";');
+      // Continuation line must have no leading whitespace of its own.
+      expect(lines[1]).toBe(
+        "strncpy(dest, smallString, 32); dest[32] = '\\0';",
+      );
     });
 
     it("throws error for string variable initialization at global scope", () => {
@@ -411,12 +452,15 @@ describe("StringDeclHelper", () => {
       );
 
       expect(result.handled).toBe(true);
-      expect(result.code).toContain('char combined[33] = "";');
-      expect(result.code).toContain("strncpy(combined, str1, 32)");
-      expect(result.code).toContain(
-        "strncat(combined, str2, 32 - strlen(combined))",
+      // Issue #1037: every line carries no indent of its own (the block emitter
+      // prefixes each line); continuation lines must not double-indent.
+      const concatLines = result.code.split("\n");
+      expect(concatLines[0]).toBe('char combined[33] = "";');
+      expect(concatLines[1]).toBe("strncpy(combined, str1, 32);");
+      expect(concatLines[2]).toBe(
+        "strncat(combined, str2, 32 - strlen(combined));",
       );
-      expect(result.code).toContain("combined[32] = '\\0';");
+      expect(concatLines[3]).toBe("combined[32] = '\\0';");
     });
 
     it("throws error for concatenation at global scope", () => {
@@ -560,9 +604,11 @@ describe("StringDeclHelper", () => {
       );
 
       expect(result.handled).toBe(true);
-      expect(result.code).toContain('char sub[11] = "";');
-      expect(result.code).toContain("strncpy(sub, srcStr + 0, 5)");
-      expect(result.code).toContain("sub[5] = '\\0';");
+      // Issue #1037: continuation lines carry no indent of their own.
+      const subLines = result.code.split("\n");
+      expect(subLines[0]).toBe('char sub[11] = "";');
+      expect(subLines[1]).toBe("strncpy(sub, srcStr + 0, 5);");
+      expect(subLines[2]).toBe("sub[5] = '\\0';");
     });
 
     it("throws error for substring at global scope", () => {