c-next 0.2.16 → 0.2.18

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

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`;
   }
 
   // ========================================================================