c-next 0.2.16 → 0.2.18

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);
+    });
+  });
+});

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

@@ -650,6 +650,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -665,6 +666,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -702,6 +704,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -728,6 +731,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -743,6 +747,7 @@ describe("TypeValidator", () => {
             type: "float",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -763,6 +768,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: true,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -778,6 +784,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -798,6 +805,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: true,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -813,6 +821,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -833,6 +842,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: true,
             arrayDims: "[10]",
           },
@@ -848,6 +858,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -1729,15 +1740,37 @@ describe("TypeValidator", () => {
   // ========================================================================
 
   describe("validateTernaryCondition", () => {
-    it("allows conditions with || operator", () => {
+    it("throws for || of bare value operands (each operand must be a comparison)", () => {
       setupState();
       const ctx = createMockOrExpression("a || b", { hasOr: true });
+      expect(() => TypeValidator.validateTernaryCondition(ctx)).toThrow(
+        "E0701",
+      );
+    });
+
+    it("allows || of comparison operands", () => {
+      setupState();
+      const ctx = createMockOrExpression("a = 1 || b = 2", {
+        hasOr: true,
+        hasEquality: true,
+      });
       expect(() => TypeValidator.validateTernaryCondition(ctx)).not.toThrow();
     });
 
-    it("allows conditions with && operator", () => {
+    it("throws for && of bare value operands (each operand must be a comparison)", () => {
       setupState();
       const ctx = createMockOrExpression("a && b", { hasAnd: true });
+      expect(() => TypeValidator.validateTernaryCondition(ctx)).toThrow(
+        "E0701",
+      );
+    });
+
+    it("allows && of comparison operands", () => {
+      setupState();
+      const ctx = createMockOrExpression("a = 1 && b = 2", {
+        hasAnd: true,
+        hasEquality: true,
+      });
       expect(() => TypeValidator.validateTernaryCondition(ctx)).not.toThrow();
     });
 
@@ -1757,7 +1790,7 @@ describe("TypeValidator", () => {
       setupState();
       const ctx = createMockOrExpression("flag");
       expect(() => TypeValidator.validateTernaryCondition(ctx)).toThrow(
-        "Ternary condition must be a boolean expression",
+        "E0701",
       );
     });
 
@@ -1768,7 +1801,7 @@ describe("TypeValidator", () => {
         andExpression: antlrArray([]),
       } as unknown as Parser.OrExpressionContext;
       expect(() => TypeValidator.validateTernaryCondition(ctx)).toThrow(
-        "Ternary condition must be a boolean expression",
+        "E0701",
       );
     });
 
@@ -1780,7 +1813,7 @@ describe("TypeValidator", () => {
         andExpression: antlrArray([andExpr]),
       } as unknown as Parser.OrExpressionContext;
       expect(() => TypeValidator.validateTernaryCondition(ctx)).toThrow(
-        "Ternary condition must be a boolean expression",
+        "E0701",
       );
     });
 
@@ -1793,7 +1826,7 @@ describe("TypeValidator", () => {
         andExpression: antlrArray([andExpr]),
       } as unknown as Parser.OrExpressionContext;
       expect(() => TypeValidator.validateTernaryCondition(ctx)).toThrow(
-        "Ternary condition must be a boolean expression",
+        "E0701",
       );
     });
   });
@@ -1887,17 +1920,39 @@ describe("TypeValidator", () => {
       ).not.toThrow();
     });
 
-    it("allows conditions with && operator", () => {
+    it("throws for && of bare value operands (each operand must be a comparison)", () => {
       setupState();
       const ctx = createFullDoWhileExpression("a && b", { hasAnd: true });
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("E0701");
+    });
+
+    it("allows && of comparison operands", () => {
+      setupState();
+      const ctx = createFullDoWhileExpression("a = 1 && b = 2", {
+        hasAnd: true,
+        hasEquality: true,
+      });
       expect(() =>
         TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
       ).not.toThrow();
     });
 
-    it("allows conditions with || operator", () => {
+    it("throws for || of bare value operands (each operand must be a comparison)", () => {
       setupState();
       const ctx = createFullDoWhileExpression("a || b", { hasOr: true });
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("E0701");
+    });
+
+    it("allows || of comparison operands", () => {
+      setupState();
+      const ctx = createFullDoWhileExpression("a = 1 || b = 2", {
+        hasOr: true,
+        hasEquality: true,
+      });
       expect(() =>
         TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
       ).not.toThrow();
@@ -1927,7 +1982,7 @@ describe("TypeValidator", () => {
       ).toThrow("E0701");
     });
 
-    it("allows boolean literals", () => {
+    it("throws for boolean literal condition (Issue #1042)", () => {
       setupState();
       // Create full mock expression tree where getText returns "true"
       const bitwiseOrExpr = {
@@ -1958,10 +2013,10 @@ describe("TypeValidator", () => {
       } as unknown as Parser.ExpressionContext;
       expect(() =>
         TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
-      ).not.toThrow();
+      ).toThrow("E0701");
     });
 
-    it("allows negation expressions", () => {
+    it("throws for negation expression (Issue #1042)", () => {
       setupState();
       const bitwiseOrExpr = {
         bitwiseXorExpression: antlrArray([]),
@@ -1991,10 +2046,10 @@ describe("TypeValidator", () => {
       } as unknown as Parser.ExpressionContext;
       expect(() =>
         TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
-      ).not.toThrow();
+      ).toThrow("E0701");
     });
 
-    it("allows bool type variables", () => {
+    it("throws for bare bool type variable (Issue #1042)", () => {
       const typeRegistry = new Map<string, TTypeInfo>([
         [
           "isReady",
@@ -2030,7 +2085,7 @@ describe("TypeValidator", () => {
       } as unknown as Parser.ExpressionContext;
       expect(() =>
         TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
-      ).not.toThrow();
+      ).toThrow("E0701");
     });
 
     it("shows help message in error", () => {
@@ -2041,6 +2096,34 @@ describe("TypeValidator", () => {
       ).toThrow("help: use explicit comparison: count > 0 or count != 0");
     });
 
+    it("suggests `= true` for a bare bool operand (Issue #1042)", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "ready",
+          { baseType: "bool", bitWidth: 8, isArray: false, isConst: false },
+        ],
+      ]);
+      setupState({ typeRegistry });
+      const ctx = createFullDoWhileExpression("ready");
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("help: use explicit comparison: ready = true");
+    });
+
+    it("suggests `= false` for a negated bool operand (Issue #1042)", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "ready",
+          { baseType: "bool", bitWidth: 8, isArray: false, isConst: false },
+        ],
+      ]);
+      setupState({ typeRegistry });
+      const ctx = createFullDoWhileExpression("!ready");
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("help: use explicit comparison: ready = false");
+    });
+
     it("throws when no andExpression", () => {
       setupState();
       const orExpr = {

package/src/transpiler/output/codegen/assignment/AssignmentClassifier.ts

@@ -415,9 +415,22 @@ class AssignmentClassifier {
     const firstId = ctx.identifiers[0];
 
     if (ctx.hasArrayAccess) {
+      // Direct register: global.REG.MEMBER[bit]
       if (CodeGenState.symbols!.knownRegisters.has(firstId)) {
         return AssignmentKind.GLOBAL_REGISTER_BIT;
       }
+      // Scoped register: global.Scope.REG.MEMBER[bit] — mirror
+      // classifyRegisterBitAccess so the bit-range mask/shift is expanded
+      // rather than emitting a literal subscript (Issue #1052).
+      if (
+        CodeGenState.isKnownScope(firstId) &&
+        ctx.identifiers.length >= 3 &&
+        CodeGenState.symbols!.knownRegisters.has(
+          `${firstId}_${ctx.identifiers[1]}`,
+        )
+      ) {
+        return AssignmentKind.GLOBAL_REGISTER_BIT;
+      }
       return AssignmentKind.GLOBAL_ARRAY;
     }
 

package/src/transpiler/output/codegen/assignment/AssignmentKind.ts

@@ -85,7 +85,7 @@ enum AssignmentKind {
   /** matrix[i][j] <- value (multi-dimensional array element) */
   MULTI_DIM_ARRAY_ELEMENT,
 
-  /** buffer[0, 10] <- source (slice assignment with memcpy) */
+  /** buffer[0, 10] <- source (slice assignment: per-element little-endian writes, ADR-007/#1081) */
   ARRAY_SLICE,
 
   // === Special operations ===

package/src/transpiler/output/codegen/assignment/handlers/AccessPatternHandlers.ts

@@ -15,12 +15,6 @@ import BitUtils from "../../../../../utils/BitUtils";
 import TAssignmentHandler from "./TAssignmentHandler";
 import RegisterUtils from "./RegisterUtils";
 import CodeGenState from "../../../../state/CodeGenState";
-import type ICodeGenApi from "../../types/ICodeGenApi";
-
-/** Get typed generator reference */
-function gen(): ICodeGenApi {
-  return CodeGenState.generator as ICodeGenApi;
-}
 
 /**
  * Common handler for global access patterns (GLOBAL_MEMBER and GLOBAL_ARRAY).
@@ -32,10 +26,15 @@ function handleGlobalAccess(ctx: IAssignmentContext): string {
 
   // Validate cross-scope visibility if first id is a scope
   if (CodeGenState.isKnownScope(firstId) && ctx.identifiers.length >= 2) {
-    gen().validateCrossScopeVisibility(firstId, ctx.identifiers[1]);
+    CodeGenState.requireGenerator().validateCrossScopeVisibility(
+      firstId,
+      ctx.identifiers[1],
+    );
   }
 
-  const target = gen().generateAssignmentTarget(ctx.targetCtx);
+  const target = CodeGenState.requireGenerator().generateAssignmentTarget(
+    ctx.targetCtx,
+  );
   return `${target} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 
@@ -49,7 +48,9 @@ function handleThisAccess(ctx: IAssignmentContext): string {
     throw new Error("Error: 'this' can only be used inside a scope");
   }
 
-  const target = gen().generateAssignmentTarget(ctx.targetCtx);
+  const target = CodeGenState.requireGenerator().generateAssignmentTarget(
+    ctx.targetCtx,
+  );
   return `${target} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 
@@ -100,7 +101,9 @@ function handleGlobalRegisterBit(ctx: IAssignmentContext): string {
   }
 
   // Single bit
-  const bitIndex = gen().generateExpression(ctx.subscripts[0]);
+  const bitIndex = CodeGenState.requireGenerator().generateExpression(
+    ctx.subscripts[0],
+  );
 
   if (isWriteOnly) {
     if (ctx.generatedValue === "false" || ctx.generatedValue === "0") {
@@ -126,7 +129,10 @@ function handleGlobalRegisterBit(ctx: IAssignmentContext): string {
  */
 function handleMemberChain(ctx: IAssignmentContext): string {
   // Check if this is bit access on a struct member
-  const bitAnalysis = gen().analyzeMemberChainForBitAccess(ctx.targetCtx);
+  const bitAnalysis =
+    CodeGenState.requireGenerator().analyzeMemberChainForBitAccess(
+      ctx.targetCtx,
+    );
 
   if (bitAnalysis.isBitAccess) {
     // Validate compound operators not supported for bit access
@@ -144,7 +150,9 @@ function handleMemberChain(ctx: IAssignmentContext): string {
   }
 
   // Normal member chain assignment
-  const target = gen().generateAssignmentTarget(ctx.targetCtx);
+  const target = CodeGenState.requireGenerator().generateAssignmentTarget(
+    ctx.targetCtx,
+  );
   return `${target} ${ctx.cOp} ${ctx.generatedValue};`;
 }