c-next 0.2.17 → 0.2.18

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

@@ -1740,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();
     });
 
@@ -1768,7 +1790,7 @@ describe("TypeValidator", () => {
       setupState();
       const ctx = createMockOrExpression("flag");
       expect(() => TypeValidator.validateTernaryCondition(ctx)).toThrow(
-        "Ternary condition must be a boolean expression",
+        "E0701",
       );
     });
 
@@ -1779,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",
       );
     });
 
@@ -1791,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",
       );
     });
 
@@ -1804,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",
       );
     });
   });
@@ -1898,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();
@@ -1938,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 = {
@@ -1969,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([]),
@@ -2002,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",
@@ -2041,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", () => {
@@ -2052,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};`;
 }