c-next 0.2.17 → 0.2.18

package/src/transpiler/logic/symbols/__tests__/SymbolTable.test.ts

@@ -772,6 +772,55 @@ describe("SymbolTable", () => {
       expect(symbolTable.isOpaqueType("handle_t")).toBe(true);
       expect(symbolTable.getAllOpaqueTypes()).toHaveLength(2);
     });
+
+    it("clearStructTagHasBody restores opacity for a phantom body (#985)", () => {
+      symbolTable.markOpaqueType("obj_t");
+      symbolTable.registerStructTagAlias("_obj", "obj_t");
+      symbolTable.markStructTagHasBody("_obj"); // phantom body from a blob parse
+      expect(symbolTable.isOpaqueType("obj_t")).toBe(false);
+
+      symbolTable.clearStructTagHasBody("_obj");
+      expect(symbolTable.isOpaqueType("obj_t")).toBe(true);
+      expect(symbolTable.getAllStructTagsWithBodies()).not.toContain("_obj");
+    });
+
+    it("clearStructTagHasBody is a no-op when the tag has no body", () => {
+      // Must not throw or spuriously mutate when the tag was never marked.
+      expect(() => symbolTable.clearStructTagHasBody("_never")).not.toThrow();
+      expect(symbolTable.getAllStructTagsWithBodies()).not.toContain("_never");
+    });
+
+    it("getStructTagForTypedef returns the aliased tag or undefined", () => {
+      symbolTable.registerStructTagAlias("_lv_obj_t", "lv_obj_t");
+      expect(symbolTable.getStructTagForTypedef("lv_obj_t")).toBe("_lv_obj_t");
+      expect(symbolTable.getStructTagForTypedef("unknown_t")).toBeUndefined();
+    });
+  });
+
+  // ========================================================================
+  // External Declaration Names (Issue #985 macro recovery)
+  // ========================================================================
+
+  describe("External Declaration Names", () => {
+    it("registers and looks up recovered function-like macro names", () => {
+      expect(symbolTable.hasExternalDeclaration("pdMS_TO_TICKS")).toBe(false);
+      symbolTable.addExternalDeclarationNames(
+        new Set(["pdMS_TO_TICKS", "portTICK_PERIOD_MS"]),
+      );
+      expect(symbolTable.hasExternalDeclaration("pdMS_TO_TICKS")).toBe(true);
+      expect(symbolTable.hasExternalDeclaration("portTICK_PERIOD_MS")).toBe(
+        true,
+      );
+      expect(symbolTable.hasExternalDeclaration("not_recovered")).toBe(false);
+    });
+
+    it("accumulates across calls and tolerates an empty set", () => {
+      symbolTable.addExternalDeclarationNames(new Set(["A"]));
+      symbolTable.addExternalDeclarationNames(new Set());
+      symbolTable.addExternalDeclarationNames(new Set(["B"]));
+      expect(symbolTable.hasExternalDeclaration("A")).toBe(true);
+      expect(symbolTable.hasExternalDeclaration("B")).toBe(true);
+    });
   });
 
   // ========================================================================

package/src/transpiler/output/MisraSuppressionUtils.ts

@@ -0,0 +1,52 @@
+/**
+ * MISRA Suppression Utilities
+ *
+ * Issue #850: Shared helpers for emitting MISRA inline suppression comments.
+ * Used by both CodeGenerator (for .c files) and HeaderGeneratorUtils (for .h files).
+ */
+
+/**
+ * Headers that violate MISRA C:2012 rules and need inline suppression.
+ * Maps header name to the MISRA rule it violates.
+ */
+const MISRA_BANNED_HEADERS: ReadonlyMap<string, string> = new Map([
+  // MISRA Rule 21.6: Standard library I/O functions shall not be used
+  ["stdio.h", "misra-c2012-21.6"],
+]);
+
+/**
+ * Regex to extract header name from angle-bracket includes.
+ * Uses possessive matching via atomic group simulation to avoid backtracking.
+ * Matches: #include <header.h> -> captures "header.h"
+ */
+const ANGLE_BRACKET_INCLUDE_REGEX = /<([^<>]+)>/;
+
+/**
+ * Check if an include directive needs MISRA suppression.
+ * @param includeText The full include directive (e.g., "#include <stdio.h>")
+ * @returns true if suppression is needed
+ */
+function needsMisraSuppression(includeText: string): boolean {
+  const match = ANGLE_BRACKET_INCLUDE_REGEX.exec(includeText);
+  if (!match) return false;
+  return MISRA_BANNED_HEADERS.has(match[1]);
+}
+
+/**
+ * Get the MISRA suppression comment for an include directive.
+ * @param includeText The full include directive (e.g., "#include <stdio.h>")
+ * @returns The suppression comment, or null if not needed
+ */
+function getMisraSuppressionComment(includeText: string): string | null {
+  const match = ANGLE_BRACKET_INCLUDE_REGEX.exec(includeText);
+  if (!match) return null;
+  const rule = MISRA_BANNED_HEADERS.get(match[1]);
+  return rule ? `// cppcheck-suppress ${rule}` : null;
+}
+
+const MisraSuppressionUtils = {
+  needsMisraSuppression,
+  getMisraSuppressionComment,
+};
+
+export default MisraSuppressionUtils;

package/src/transpiler/output/__tests__/MisraSuppressionUtils.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import MisraSuppressionUtils from "../MisraSuppressionUtils";
+
+describe("MisraSuppressionUtils", () => {
+  describe("needsMisraSuppression", () => {
+    it("returns true for stdio.h", () => {
+      expect(
+        MisraSuppressionUtils.needsMisraSuppression("#include <stdio.h>"),
+      ).toBe(true);
+    });
+
+    it("returns false for other system headers", () => {
+      expect(
+        MisraSuppressionUtils.needsMisraSuppression("#include <stdint.h>"),
+      ).toBe(false);
+      expect(
+        MisraSuppressionUtils.needsMisraSuppression("#include <string.h>"),
+      ).toBe(false);
+    });
+
+    it("returns false for quote includes", () => {
+      expect(
+        MisraSuppressionUtils.needsMisraSuppression('#include "stdio.h"'),
+      ).toBe(false);
+    });
+
+    it("returns false for non-include text", () => {
+      expect(MisraSuppressionUtils.needsMisraSuppression("void foo();")).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("getMisraSuppressionComment", () => {
+    it("returns suppression comment for stdio.h", () => {
+      expect(
+        MisraSuppressionUtils.getMisraSuppressionComment("#include <stdio.h>"),
+      ).toBe("// cppcheck-suppress misra-c2012-21.6");
+    });
+
+    it("returns null for other system headers", () => {
+      expect(
+        MisraSuppressionUtils.getMisraSuppressionComment("#include <stdint.h>"),
+      ).toBeNull();
+    });
+
+    it("returns null for quote includes", () => {
+      expect(
+        MisraSuppressionUtils.getMisraSuppressionComment('#include "stdio.h"'),
+      ).toBeNull();
+    });
+
+    it("returns null for non-include text", () => {
+      expect(
+        MisraSuppressionUtils.getMisraSuppressionComment("void foo();"),
+      ).toBeNull();
+    });
+
+    it("handles whitespace in include directives", () => {
+      expect(
+        MisraSuppressionUtils.getMisraSuppressionComment(
+          "#include  <stdio.h>  ",
+        ),
+      ).toBe("// cppcheck-suppress misra-c2012-21.6");
+    });
+  });
+});

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -148,6 +148,7 @@ import EnumTypeResolver from "./resolution/EnumTypeResolver";
 import ScopeResolver from "./resolution/ScopeResolver";
 // Issue #797: Centralized C-style name generation
 import QualifiedNameGenerator from "./utils/QualifiedNameGenerator";
+import MisraSuppressionUtils from "../MisraSuppressionUtils";
 
 const {
   generateOverflowHelpers: helperGenerateOverflowHelpers,
@@ -299,6 +300,10 @@ export default class CodeGenerator implements IOrchestrator {
       controlFlowGenerators.generateDoWhile,
     );
     this.registry.registerStatement("for", controlFlowGenerators.generateFor);
+    this.registry.registerStatement(
+      "forever",
+      controlFlowGenerators.generateForever,
+    );
     this.registry.registerStatement("switch", switchGenerators.generateSwitch);
     this.registry.registerStatement("critical", generateCriticalStatement);
 
@@ -1057,6 +1062,8 @@ export default class CodeGenerator implements IOrchestrator {
       result = this.generateDoWhile(ctx.doWhileStatement()!);
     } else if (ctx.forStatement()) {
       result = this.generateFor(ctx.forStatement()!);
+    } else if (ctx.foreverStatement()) {
+      result = this.generateForever(ctx.foreverStatement()!);
     } else if (ctx.switchStatement()) {
       result = this.generateSwitch(ctx.switchStatement()!);
     } else if (ctx.returnStatement()) {
@@ -1122,6 +1129,14 @@ export default class CodeGenerator implements IOrchestrator {
     TypeValidator.validateConditionIsBoolean(ctx, conditionType);
   }
 
+  /**
+   * ADR-113 / #1075: reject an always-true literal loop condition (E0707).
+   * Part of IOrchestrator interface.
+   */
+  validateLoopConditionNotAlwaysTrue(ctx: Parser.ExpressionContext): void {
+    TypeValidator.validateLoopConditionNotAlwaysTrue(ctx);
+  }
+
   /**
    * Issue #254: Validate no function calls in condition (E0702).
    * Part of IOrchestrator interface (ADR-053 A3).
@@ -1164,8 +1179,6 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Issue #779: Resolve bare scope member identifiers before postfix chain processing
     // This ensures scope members get their prefix even with array/member access.
-    // Skip parameters - they don't need scope resolution and shouldn't be dereferenced
-    // when used with array indexing (buf[idx] is valid C for pointer params).
     // Also skip known registers - they should be handled by the postfix chain builder
     // to enable proper register validation (requiring global. when shadowed).
     let resolvedIdentifier = identifier ?? "";
@@ -1174,7 +1187,24 @@ export default class CodeGenerator implements IOrchestrator {
       const isLocalVariable = CodeGenState.localVariables.has(identifier);
       const isKnownRegister =
         CodeGenState.symbols?.knownRegisters.has(identifier);
-      if (!isParameter && !isLocalVariable && !isKnownRegister) {
+      // Issue #1100: Parameters with postfix ops (array/bit subscript, member
+      // access) must resolve through the same dereference logic as a bare
+      // parameter reference (ParameterDereferenceResolver), not skip it.
+      // For array/struct/string/etc. parameters this is a no-op (they're
+      // already pointer-like, matching the prior behavior verbatim — e.g.
+      // `buf[idx]` stays `buf[idx]`). For a scalar parameter that became a
+      // pointer because it's modified elsewhere in the function, a bit
+      // access (`v[4] <- true`) now correctly dereferences to `(*v)[4]`
+      // (which AssignmentContextBuilder reduces to base identifier `(*v)`)
+      // instead of assigning through the raw pointer.
+      if (isParameter) {
+        const paramInfo = CodeGenState.currentParameters.get(identifier)!;
+        resolvedIdentifier = ParameterDereferenceResolver.resolve(
+          identifier,
+          paramInfo,
+          this._buildParameterDereferenceDeps(),
+        );
+      } else if (!isLocalVariable && !isKnownRegister) {
         const resolved = TypeValidator.resolveBareIdentifier(
           identifier,
           false, // not local
@@ -2362,7 +2392,14 @@ export default class CodeGenerator implements IOrchestrator {
         includePaths,
       );
 
-      output.push(this.transformIncludeDirective(includeDir.getText()));
+      // Issue #850: Add MISRA suppression for banned headers
+      const includeText = includeDir.getText();
+      const suppression =
+        MisraSuppressionUtils.getMisraSuppressionComment(includeText);
+      if (suppression) {
+        output.push(suppression);
+      }
+      output.push(this.transformIncludeDirective(includeText));
     }
 
     if (tree.includeDirective().length > 0) {
@@ -4519,6 +4556,10 @@ export default class CodeGenerator implements IOrchestrator {
     return this.invokeStatement("for", ctx);
   }
 
+  private generateForever(ctx: Parser.ForeverStatementContext): string {
+    return this.invokeStatement("forever", ctx);
+  }
+
   private generateReturn(ctx: Parser.ReturnStatementContext): string {
     return this.invokeStatement("return", ctx);
   }

package/src/transpiler/output/codegen/TypeResolver.ts

@@ -2,6 +2,7 @@
  * TypeResolver - Handles type inference, classification, and validation
  * Static class that reads from CodeGenState directly.
  */
+import { ParserRuleContext } from "antlr4ng";
 import * as Parser from "../../logic/parser/grammar/CNextParser";
 import CodeGenState from "../../state/CodeGenState";
 import INTEGER_TYPES from "./types/INTEGER_TYPES";
@@ -230,6 +231,153 @@ class TypeResolver {
     return null;
   }
 
+  /**
+   * Resolve the C-Next integer type of an expression, including composite
+   * arithmetic/bitwise expressions that `getExpressionType` leaves unresolved.
+   *
+   * MISRA C:2012 Rule 10.4 (enforced by MixedTypeCategoryAnalyzer) guarantees a
+   * binary operator's operands share an essential type category, so a composite
+   * integer expression's category is uniform; its essential width is the widest
+   * integer operand. This is what lets slice-assignment serialize an arithmetic
+   * source (e.g. `a + b`) MISRA Rule 10.8-clean instead of guessing a width.
+   *
+   * Returns null when no integer-typed variable leaf can be resolved (e.g. a
+   * struct-field or function-call composite — left for a later pass).
+   */
+  static getIntegerExpressionType(
+    ctx: Parser.ExpressionContext,
+  ): string | null {
+    const direct = TypeResolver.getExpressionType(ctx);
+    if (direct !== null) return direct;
+    return TypeResolver.resolveCompositeIntegerType(ctx);
+  }
+
+  /**
+   * Combine the leaf VALUE operands of a composite expression into a single
+   * C-Next type: the (uniform, per Rule 10.4) category at the widest width.
+   *
+   * Operands are typed by their value (Issue #1085 review) — an array index
+   * (`arr[i]`), bit offset (`x[off, w]`) or struct member name is NOT a value
+   * operand and must not contribute to the width. A bit-extraction contributes
+   * its EXTRACTED width, not the variable's full width (typing `a + b[0, 32]`
+   * as u64 would cast the composite to a wider type — MISRA Rule 10.8).
+   */
+  private static resolveCompositeIntegerType(
+    ctx: Parser.ExpressionContext,
+  ): string | null {
+    let category: "i" | "u" | null = null;
+    let width = 0;
+
+    for (const operand of TypeResolver.collectOperandPostfixes(ctx)) {
+      const operandType = TypeResolver.typeOperandPostfix(operand);
+      const match = operandType
+        ? /^([iu])(8|16|32|64)$/.exec(operandType)
+        : null;
+      if (!match) continue;
+      category ??= match[1] as "i" | "u";
+      width = Math.max(width, Number.parseInt(match[2], 10));
+    }
+
+    return category && width > 0 ? `${category}${width}` : null;
+  }
+
+  /**
+   * Type one leaf operand of a composite by its VALUE type. A bit-extraction
+   * `x[start, width]` yields an unsigned value of the extracted width; a simple
+   * function call `name(...)` yields its declared return type; everything else
+   * (variable, array element, struct field, member chain) defers to
+   * getPostfixExpressionType. Returns null for an operand it cannot classify
+   * (e.g. a literal, which is contextually typed).
+   */
+  private static typeOperandPostfix(
+    postfix: Parser.PostfixExpressionContext,
+  ): string | null {
+    const extractionWidth = TypeResolver.bitExtractionWidth(postfix);
+    if (extractionWidth !== null) {
+      return TypeResolver.unsignedTypeForBits(extractionWidth);
+    }
+
+    const direct = TypeResolver.getPostfixExpressionType(postfix);
+    if (direct !== null) return direct;
+
+    return TypeResolver.callReturnType(postfix);
+  }
+
+  /**
+   * Collect the leaf operand postfix expressions of a composite WITHOUT
+   * descending into a postfix's own internals — so an array index (`arr[i]`) or
+   * bit offset (`x[off, w]`) variable is never mistaken for a value operand.
+   */
+  private static collectOperandPostfixes(
+    node: ParserRuleContext,
+  ): Parser.PostfixExpressionContext[] {
+    if (node instanceof Parser.PostfixExpressionContext) return [node];
+    const operands: Parser.PostfixExpressionContext[] = [];
+    for (let i = 0; i < node.getChildCount(); i += 1) {
+      const child = node.getChild(i);
+      if (child instanceof ParserRuleContext) {
+        operands.push(...TypeResolver.collectOperandPostfixes(child));
+      }
+    }
+    return operands;
+  }
+
+  /**
+   * If a postfix expression's terminal suffix is a bit-range extraction
+   * `[start, width]` with a compile-time-constant width, return that width in
+   * bits; else null.
+   */
+  private static bitExtractionWidth(
+    postfix: Parser.PostfixExpressionContext,
+  ): number | null {
+    const ops = postfix.postfixOp();
+    const last = ops.at(-1);
+    if (last?.expression().length !== 2) return null;
+    const widthExpr = last.expression()[1];
+
+    // Resolve the width through the constant evaluator — the same path the slice
+    // offset/length use — so a named const or any-base literal width
+    // (`b[0, WIDTH]`, `b[0, 0b100000]`) is sized at its real width rather than
+    // dropped, which would mis-type a composite slice source (Issue #1085 review).
+    const evaluated = CodeGenState.generator?.tryEvaluateConstant(widthExpr);
+    if (evaluated !== undefined) {
+      return evaluated > 0 ? evaluated : null;
+    }
+
+    // Fallback for contexts with no generator (e.g. isolated unit tests): accept
+    // a plain decimal/hex literal width directly.
+    const widthText = widthExpr.getText();
+    if (!/^(0x[0-9a-fA-F]+|\d+)$/.test(widthText)) return null;
+    const value = Number.parseInt(
+      widthText,
+      widthText.startsWith("0x") ? 16 : 10,
+    );
+    return Number.isNaN(value) || value <= 0 ? null : value;
+  }
+
+  /** Smallest standard unsigned C-Next type holding `bits` bits, or null if >64. */
+  private static unsignedTypeForBits(bits: number): string | null {
+    if (bits <= 8) return "u8";
+    if (bits <= 16) return "u16";
+    if (bits <= 32) return "u32";
+    if (bits <= 64) return "u64";
+    return null;
+  }
+
+  /**
+   * If a postfix expression is a simple function call `name(...)`, return the
+   * function's declared return type — a call operand's width comes from its
+   * return type, not from being ignored (Issue #1085 review).
+   */
+  private static callReturnType(
+    postfix: Parser.PostfixExpressionContext,
+  ): string | null {
+    const ops = postfix.postfixOp();
+    if (ops.length !== 1 || !ops[0].getText().startsWith("(")) return null;
+    const name = postfix.primaryExpression()?.IDENTIFIER()?.getText();
+    return name ? (CodeGenState.getFunctionReturnType(name) ?? null) : null;
+  }
+
   /**
    * ADR-024: Get the type of a postfix expression.
    * Tracks InternalTypeInfo (baseType + isArray) through the suffix chain