c-next 0.2.17 → 0.2.18

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

@@ -657,48 +657,7 @@ class TypeValidator {
   // ========================================================================
 
   static validateTernaryCondition(ctx: Parser.OrExpressionContext): void {
-    const text = ctx.getText();
-
-    if (ctx.andExpression().length > 1) {
-      return;
-    }
-
-    const andExpr = ctx.andExpression(0);
-    if (!andExpr) {
-      throw new Error(
-        `Error: Ternary condition must be a boolean expression (comparison or logical operation), not '${text}'`,
-      );
-    }
-
-    if (andExpr.equalityExpression().length > 1) {
-      return;
-    }
-
-    const equalityExpr = andExpr.equalityExpression(0);
-    if (!equalityExpr) {
-      throw new Error(
-        `Error: Ternary condition must be a boolean expression (comparison or logical operation), not '${text}'`,
-      );
-    }
-
-    if (equalityExpr.relationalExpression().length > 1) {
-      return;
-    }
-
-    const relationalExpr = equalityExpr.relationalExpression(0);
-    if (!relationalExpr) {
-      throw new Error(
-        `Error: Ternary condition must be a boolean expression (comparison or logical operation), not '${text}'`,
-      );
-    }
-
-    if (relationalExpr.bitwiseOrExpression().length > 1) {
-      return;
-    }
-
-    throw new Error(
-      `Error: Ternary condition must be a boolean expression (comparison or logical operation), not '${text}'`,
-    );
+    TypeValidator._validateConditionOrExpression(ctx, "ternary");
   }
 
   static validateNoNestedTernary(
@@ -730,75 +689,214 @@ class TypeValidator {
       );
     }
 
-    const orExpr = orExprs[0];
-    const text = orExpr.getText();
-
-    if (orExpr.andExpression().length > 1) {
-      return;
-    }
+    TypeValidator._validateConditionOrExpression(orExprs[0], conditionType);
+  }
 
-    const andExpr = orExpr.andExpression(0);
-    if (!andExpr) {
-      throw new Error(
-        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`,
-      );
+  /**
+   * MISRA C:2012 Rule 14.4 (Issue #1042): a controlling expression must be an
+   * explicit comparison. Every leaf operand — after decomposing `||` and `&&` —
+   * must itself be an equality (`=`, `!=`) or relational (`<`, `>`, `<=`, `>=`)
+   * comparison. A bare value, a bare boolean (local, parameter, or `this.`/
+   * `global.` member), a literal, or a negation (`!x`) is rejected; use an
+   * explicit form such as `x = true`. This is the single decision point shared
+   * by `if`/`while`/`for`/`do-while` and ternary conditions.
+   */
+  private static _validateConditionOrExpression(
+    orExpr: Parser.OrExpressionContext,
+    conditionType: string,
+  ): void {
+    const andExprs = orExpr.andExpression();
+    if (andExprs.length === 0) {
+      TypeValidator._throwConditionNotBoolean(orExpr, conditionType);
     }
 
-    if (andExpr.equalityExpression().length > 1) {
-      return;
-    }
+    for (const andExpr of andExprs) {
+      const equalityExprs = andExpr.equalityExpression();
+      if (equalityExprs.length === 0) {
+        TypeValidator._throwConditionNotBoolean(orExpr, conditionType);
+      }
 
-    const equalityExpr = andExpr.equalityExpression(0);
-    if (!equalityExpr) {
-      throw new Error(
-        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`,
-      );
+      for (const equalityExpr of equalityExprs) {
+        TypeValidator._validateConditionIsComparison(
+          equalityExpr,
+          orExpr,
+          conditionType,
+        );
+      }
     }
+  }
 
+  private static _validateConditionIsComparison(
+    equalityExpr: Parser.EqualityExpressionContext,
+    orExpr: Parser.OrExpressionContext,
+    conditionType: string,
+  ): void {
+    // An equality operator (`=`, `!=`) makes this operand a comparison.
     if (equalityExpr.relationalExpression().length > 1) {
       return;
     }
 
     const relationalExpr = equalityExpr.relationalExpression(0);
     if (!relationalExpr) {
-      throw new Error(
-        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`,
-      );
+      TypeValidator._throwConditionNotBoolean(orExpr, conditionType);
+      return;
     }
 
+    // A relational operator (`<`, `>`, `<=`, `>=`) makes this operand a comparison.
     if (relationalExpr.bitwiseOrExpression().length > 1) {
       return;
     }
 
-    const bitwiseOrExpr = relationalExpr.bitwiseOrExpression(0);
-    if (bitwiseOrExpr && TypeValidator._isBooleanExpression(bitwiseOrExpr)) {
-      return;
-    }
+    // No comparison operator: a bare value, bare boolean, literal, or negation.
+    TypeValidator._throwConditionNotBoolean(equalityExpr, conditionType);
+  }
 
+  private static _throwConditionNotBoolean(
+    node: Parser.OrExpressionContext | Parser.EqualityExpressionContext,
+    conditionType: string,
+  ): void {
+    const text = node.getText();
     throw new Error(
-      `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)\n  help: use explicit comparison: ${text} > 0 or ${text} != 0`,
+      `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)\n  help: ${TypeValidator._conditionHelp(text)}`,
     );
   }
 
-  private static _isBooleanExpression(
-    ctx: Parser.BitwiseOrExpressionContext,
-  ): boolean {
-    const text = ctx.getText();
+  // ========================================================================
+  // Disguised Infinite Loop Validation (ADR-113 / #1075, E0707)
+  // ========================================================================
 
-    if (text === "true" || text === "false") {
-      return true;
+  /**
+   * ADR-113 / #1075 (E0707): reject a loop whose controlling expression is an
+   * always-TRUE comparison of literal operands (`while (1 = 1)`, `5 > 3`,
+   * `true = true`). C-Next has one source form for an intentional infinite loop —
+   * `forever`. This is the v0.2.18 *literal* slice only: named constants and
+   * non-literal operands need symbol resolution (out of scope), and always-FALSE
+   * conditions are a separate MISRA 14.3 case — both tracked in #1076.
+   *
+   * Runs after the E0701 boolean check, so the condition is already a comparison.
+   */
+  static validateLoopConditionNotAlwaysTrue(
+    ctx: Parser.ExpressionContext,
+  ): void {
+    const comparison = TypeValidator._asSingleLiteralComparison(ctx);
+    if (comparison && TypeValidator._comparisonIsAlwaysTrue(comparison)) {
+      throw new Error(
+        `Error E0707: loop condition '${ctx.getText()}' is always true\n` +
+          "  help: write 'forever { ... }' for an intentional infinite loop",
+      );
     }
+  }
 
-    if (text.startsWith("!")) {
-      return true;
+  /**
+   * If `ctx` is a single comparison of two literal operands (no `||`/`&&`, no
+   * ternary, no chaining), return its operator and the two literal values.
+   * Otherwise null — anything involving identifiers, floats, or sub-expressions
+   * is left to the full MISRA 14.3 effort (#1076).
+   */
+  private static _asSingleLiteralComparison(
+    ctx: Parser.ExpressionContext,
+  ): { operator: string; left: number; right: number } | null {
+    const orExprs = ctx.ternaryExpression().orExpression();
+    if (orExprs.length !== 1) return null;
+    const andExprs = orExprs[0].andExpression();
+    if (andExprs.length !== 1) return null;
+    const equalityExprs = andExprs[0].equalityExpression();
+    if (equalityExprs.length !== 1) return null;
+    const equalityExpr = equalityExprs[0];
+
+    const relationalExprs = equalityExpr.relationalExpression();
+    if (relationalExprs.length === 2) {
+      // Equality comparison: relExpr ('=' | '!=') relExpr
+      return TypeValidator._buildLiteralComparison(
+        equalityExpr.getChild(1)?.getText(),
+        relationalExprs[0].getText(),
+        relationalExprs[1].getText(),
+      );
+    }
+    if (relationalExprs.length === 1) {
+      const bitwiseOrExprs = relationalExprs[0].bitwiseOrExpression();
+      if (bitwiseOrExprs.length === 2) {
+        // Relational comparison: orExpr ('<' | '>' | '<=' | '>=') orExpr
+        return TypeValidator._buildLiteralComparison(
+          relationalExprs[0].getChild(1)?.getText(),
+          bitwiseOrExprs[0].getText(),
+          bitwiseOrExprs[1].getText(),
+        );
+      }
     }
+    return null;
+  }
 
-    const typeInfo = CodeGenState.getVariableTypeInfo(text);
-    if (typeInfo?.baseType === "bool") {
-      return true;
+  private static _buildLiteralComparison(
+    operator: string | undefined,
+    leftText: string,
+    rightText: string,
+  ): { operator: string; left: number; right: number } | null {
+    const left = TypeValidator._literalValue(leftText);
+    const right = TypeValidator._literalValue(rightText);
+    if (operator === undefined || left === null || right === null) return null;
+    return { operator, left, right };
+  }
+
+  /**
+   * Strict literal-to-number for the E0707 literal slice: integer literals
+   * (decimal/hex/binary, optional type suffix) and `true`/`false`. Floats,
+   * strings, chars, identifiers, and any compound text return null so they are
+   * not treated as compile-time-known.
+   */
+  private static _literalValue(text: string): number | null {
+    if (text === "true") return 1;
+    if (text === "false") return 0;
+    if (text.includes(".")) return null;
+    // A leading-zero integer (`0777`) is emitted verbatim and read by C as an
+    // OCTAL constant, so a decimal parse would diverge from the generated code's
+    // value. Skip it (defer to #1076) rather than risk a wrong verdict. `0x`/`0b`
+    // and a bare `0` are unambiguous and still handled.
+    if (/^0\d/.test(text)) return null;
+    if (/^(0[xX][\da-fA-F]+|0[bB][01]+|\d+)([uUiI]\d+)?$/.test(text)) {
+      return LiteralEvaluator.parseLiteral(text);
     }
+    return null;
+  }
 
-    return false;
+  private static _comparisonIsAlwaysTrue(comparison: {
+    operator: string;
+    left: number;
+    right: number;
+  }): boolean {
+    switch (comparison.operator) {
+      case "=":
+        return comparison.left === comparison.right;
+      case "!=":
+        return comparison.left !== comparison.right;
+      case "<":
+        return comparison.left < comparison.right;
+      case ">":
+        return comparison.left > comparison.right;
+      case "<=":
+        return comparison.left <= comparison.right;
+      case ">=":
+        return comparison.left >= comparison.right;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Builds a context-aware "help" suggestion for a rejected condition. For a
+   * boolean operand the correct explicit form is `flag = true` (or `flag = false`
+   * for a negated `!flag`), not a numeric `> 0` comparison. Non-boolean operands
+   * keep the generic `> 0 or != 0` guidance. A member access (`this.flag`) that
+   * does not resolve to a known type falls back to the generic form.
+   */
+  private static _conditionHelp(text: string): string {
+    const isNegated = text.startsWith("!");
+    const base = isNegated ? text.slice(1) : text;
+    const typeInfo = CodeGenState.getVariableTypeInfo(base);
+    if (typeInfo?.baseType === "bool") {
+      return `use explicit comparison: ${base} = ${isNegated ? "false" : "true"}`;
+    }
+    return `use explicit comparison: ${text} > 0 or ${text} != 0`;
   }
 
   // ========================================================================

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

@@ -8454,6 +8454,17 @@ describe("CodeGenerator", () => {
         const generator = new CodeGenerator();
         const tSymbols = CNextResolver.resolve(tree, "test.cnx");
         const symbols = TSymbolInfoAdapter.convert(tSymbols);
+        // Issue #1100: SymbolTable must be wired up (as the real Transpiler
+        // pipeline always does, see setupGenerator() above) so
+        // getMemberTypeInfo() can resolve struct field array-ness. Without
+        // this, getStructFieldInfo() always returns null and the struct
+        // field's array-ness is never determined via the correct path — this
+        // test was previously passing only because a since-removed blanket
+        // "parameter -> array access" rule (Issue #579) coincidentally
+        // produced the right output for the wrong reason.
+        const symbolTable = new SymbolTable();
+        symbolTable.addTSymbols(tSymbols);
+        CodeGenState.symbolTable = symbolTable;
 
         const code = generator.generate(tree, tokenStream, {
           symbolInfo: symbols,
@@ -14922,7 +14933,8 @@ describe("CodeGenerator", () => {
       it("should reject break - not part of C-Next spec", () => {
         const source = `
           void test() {
-            while (true) {
+            u32 i <- 0;
+            while (i < 10) {
               break;
             }
           }

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

@@ -3,10 +3,20 @@
  * Tests type classification, conversion validation, and literal validation
  */
 import { describe, it, expect, beforeEach } from "vitest";
+import { CharStream, CommonTokenStream } from "antlr4ng";
 import TypeResolver from "../TypeResolver";
 import SymbolTable from "../../../logic/symbols/SymbolTable";
 import CodeGenState from "../../../state/CodeGenState";
 import TTypeInfo from "../types/TTypeInfo";
+import { CNextLexer } from "../../../logic/parser/grammar/CNextLexer";
+import { CNextParser } from "../../../logic/parser/grammar/CNextParser";
+
+/** Parse a standalone C-Next expression into an ExpressionContext. */
+function parseExpression(source: string) {
+  const lexer = new CNextLexer(CharStream.fromString(source));
+  const parser = new CNextParser(new CommonTokenStream(lexer));
+  return parser.expression();
+}
 
 describe("TypeResolver", () => {
   let symbolTable: SymbolTable;
@@ -598,6 +608,89 @@ describe("TypeResolver", () => {
     });
   });
 
+  describe("getIntegerExpressionType", () => {
+    function setInt(name: string, baseType: string, bitWidth: number): void {
+      setTypeInfo(name, { baseType, bitWidth, isArray: false, isConst: false });
+    }
+
+    it("resolves a signed composite to its operand category and width", () => {
+      setInt("a", "i32", 32);
+      setInt("b", "i32", 32);
+      expect(
+        TypeResolver.getIntegerExpressionType(parseExpression("a + b")),
+      ).toBe("i32");
+    });
+
+    it("resolves an unsigned composite to its operand category and width", () => {
+      setInt("a", "u32", 32);
+      setInt("b", "u32", 32);
+      expect(
+        TypeResolver.getIntegerExpressionType(parseExpression("a | b")),
+      ).toBe("u32");
+    });
+
+    it("uses the widest operand width across a same-category composite", () => {
+      setInt("small", "u8", 8);
+      setInt("big", "u32", 32);
+      expect(
+        TypeResolver.getIntegerExpressionType(parseExpression("small + big")),
+      ).toBe("u32");
+    });
+
+    it("still resolves a simple variable via getExpressionType", () => {
+      setInt("x", "i16", 16);
+      expect(TypeResolver.getIntegerExpressionType(parseExpression("x"))).toBe(
+        "i16",
+      );
+    });
+
+    it("returns null when no integer variable leaf can be resolved", () => {
+      expect(
+        TypeResolver.getIntegerExpressionType(parseExpression("a + b")),
+      ).toBeNull();
+    });
+
+    it("ignores integer literals (contextually typed, not fixed-category)", () => {
+      setInt("a", "u32", 32);
+      expect(
+        TypeResolver.getIntegerExpressionType(parseExpression("a + 5")),
+      ).toBe("u32");
+    });
+
+    it("narrows a bit-extraction operand to the extracted width, not the variable's full width", () => {
+      setInt("a", "u32", 32);
+      setInt("b", "u64", 64);
+      // b[0, 32] is u32, so a + b[0, 32] is u32 — NOT u64. Typing it u64 would
+      // make slice codegen cast the composite to a wider type (MISRA 10.8).
+      expect(
+        TypeResolver.getIntegerExpressionType(parseExpression("a + b[0, 32]")),
+      ).toBe("u32");
+    });
+
+    it("types an array-element operand by its element type, ignoring the index variable's width", () => {
+      setTypeInfo("arr", {
+        baseType: "u8",
+        bitWidth: 8,
+        isArray: true,
+        isConst: false,
+      });
+      setInt("idx", "u64", 64);
+      setInt("a", "u8", 8);
+      // arr[idx] is u8 (the element); a wide index must not inflate the width.
+      expect(
+        TypeResolver.getIntegerExpressionType(parseExpression("a + arr[idx]")),
+      ).toBe("u8");
+    });
+
+    it("types a bit-extraction operand by the extracted width when it is the widest operand", () => {
+      setInt("b", "u64", 64);
+      setInt("c", "u8", 8);
+      expect(
+        TypeResolver.getIntegerExpressionType(parseExpression("b[0, 32] + c")),
+      ).toBe("u32");
+    });
+  });
+
   // ========================================================================
   // Postfix Expression Type Detection
   // ========================================================================

package/src/transpiler/output/codegen/__tests__/TypeValidator.alwaysTrueLoop.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Unit tests for TypeValidator.validateLoopConditionNotAlwaysTrue
+ * ADR-113 / Issue #1075: reject always-true literal loop conditions (E0707).
+ *
+ * Only the v0.2.18 literal slice — integer/bool literal comparisons decided
+ * without symbol resolution. Named constants, non-literal operands, and
+ * always-false conditions are out of scope (#1076).
+ */
+import { describe, it, expect } from "vitest";
+import { CharStream, CommonTokenStream } from "antlr4ng";
+import { CNextLexer } from "../../../logic/parser/grammar/CNextLexer";
+import { CNextParser } from "../../../logic/parser/grammar/CNextParser";
+import TypeValidator from "../TypeValidator";
+
+function parseCondition(text: string) {
+  const charStream = CharStream.fromString(text);
+  const lexer = new CNextLexer(charStream);
+  const tokenStream = new CommonTokenStream(lexer);
+  const parser = new CNextParser(tokenStream);
+  return parser.expression();
+}
+
+function isFlaggedAlwaysTrue(text: string): boolean {
+  try {
+    TypeValidator.validateLoopConditionNotAlwaysTrue(parseCondition(text));
+    return false;
+  } catch (error) {
+    return /E0707/.test((error as Error).message);
+  }
+}
+
+describe("TypeValidator.validateLoopConditionNotAlwaysTrue (E0707)", () => {
+  describe("flags always-true literal comparisons", () => {
+    it.each([
+      "1 = 1",
+      "true = true",
+      "false = false",
+      "1 != 2",
+      "5 > 3",
+      "3 < 5",
+      "3 >= 3",
+      "5 <= 5",
+      "0x10 = 16",
+      "0XFF = 255", // uppercase hex prefix
+      "0b10 = 2",
+      "5u8 = 5", // type-suffixed literal
+    ])("flags %s", (condition) => {
+      expect(isFlaggedAlwaysTrue(condition)).toBe(true);
+    });
+
+    it("includes the condition text and steers to forever", () => {
+      let message = "";
+      try {
+        TypeValidator.validateLoopConditionNotAlwaysTrue(
+          parseCondition("1 = 1"),
+        );
+      } catch (error) {
+        message = (error as Error).message;
+      }
+      expect(message).toContain(
+        "Error E0707: loop condition '1=1' is always true",
+      );
+      expect(message).toContain("forever { ... }");
+    });
+  });
+
+  describe("does NOT flag always-false comparisons (out of scope, #1076)", () => {
+    it.each(["1 = 2", "true = false", "1 != 1", "5 < 3", "3 > 5", "5 <= 3"])(
+      "allows %s",
+      (condition) => {
+        expect(isFlaggedAlwaysTrue(condition)).toBe(false);
+      },
+    );
+  });
+
+  describe("does NOT flag non-literal or compound conditions (needs folding, #1076)", () => {
+    it.each([
+      "x = 1", // identifier operand
+      "MAX > 0", // named constant
+      "a = b", // two identifiers
+      "5.0 > 3.0", // float operands
+      "1 + 0 = 1", // compound left operand
+      "1 = 1 || 0 > 5", // logical-or combination
+      "1 = 1 && 2 = 2", // logical-and combination
+      "0777 = 777", // leading-zero literal: C reads it as octal (511), so a
+      // decimal parse (777) would diverge — skipped, not wrongly flagged
+    ])("allows %s", (condition) => {
+      expect(isFlaggedAlwaysTrue(condition)).toBe(false);
+    });
+  });
+});