c-next 0.2.6 → 0.2.7

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

@@ -112,14 +112,13 @@ describe("SymbolUtils", () => {
 
   // ========================================================================
   // Reserved Field Names
+  // ADR-058: .length removed, so "length" is no longer reserved
   // ========================================================================
 
   describe("isReservedFieldName", () => {
-    it("should return true for reserved names", () => {
-      expect(SymbolUtils.isReservedFieldName("length")).toBe(true);
-    });
-
-    it("should return false for non-reserved names", () => {
+    it("should return false for all names (no reserved names after ADR-058)", () => {
+      // "length" is no longer reserved since .length was deprecated
+      expect(SymbolUtils.isReservedFieldName("length")).toBe(false);
       expect(SymbolUtils.isReservedFieldName("x")).toBe(false);
       expect(SymbolUtils.isReservedFieldName("data")).toBe(false);
       expect(SymbolUtils.isReservedFieldName("size")).toBe(false);
@@ -128,10 +127,10 @@ describe("SymbolUtils", () => {
   });
 
   describe("getReservedFieldNames", () => {
-    it("should return array of reserved names", () => {
+    it("should return empty array (no reserved names after ADR-058)", () => {
       const reserved = SymbolUtils.getReservedFieldNames();
       expect(Array.isArray(reserved)).toBe(true);
-      expect(reserved).toContain("length");
+      expect(reserved).toHaveLength(0);
     });
   });
 
@@ -140,11 +139,11 @@ describe("SymbolUtils", () => {
       const msg = SymbolUtils.getReservedFieldWarning(
         "C",
         "MyStruct",
-        "length",
+        "someField",
       );
       expect(msg).toContain("C header struct");
       expect(msg).toContain("MyStruct");
-      expect(msg).toContain("length");
+      expect(msg).toContain("someField");
       expect(msg).toContain("conflicts with C-Next");
     });
 
@@ -152,11 +151,11 @@ describe("SymbolUtils", () => {
       const msg = SymbolUtils.getReservedFieldWarning(
         "C++",
         "MyClass",
-        "length",
+        "someField",
       );
       expect(msg).toContain("C++ header struct");
       expect(msg).toContain("MyClass");
-      expect(msg).toContain("length");
+      expect(msg).toContain("someField");
     });
   });
 });

package/src/transpiler/logic/symbols/c/__tests__/CResolver.integration.test.ts

@@ -350,14 +350,14 @@ describe("CResolver - Struct Fields", () => {
     expect(fieldsMap?.get("inner")?.type).toBe("Inner");
   });
 
-  it("warns about reserved field names", () => {
+  // ADR-058: "length" is no longer reserved since .length was deprecated
+  it("does not warn about 'length' field names after ADR-058", () => {
     const tree = TestHelpers.parseC(`struct Test { int length; };`);
     const symbolTable = new SymbolTable();
     const result = CResolver.resolve(tree!, "test.h", symbolTable);
 
-    expect(result.warnings.length).toBeGreaterThan(0);
-    expect(result.warnings[0]).toContain("length");
-    expect(result.warnings[0]).toContain("conflicts with C-Next");
+    // No warnings since "length" is no longer reserved
+    expect(result.warnings.length).toBe(0);
   });
 });
 

package/src/transpiler/logic/symbols/cpp/__tests__/CppResolver.integration.test.ts

@@ -255,16 +255,16 @@ describe("CppResolver", () => {
     });
   });
 
+  // ADR-058: "length" is no longer reserved since .length was deprecated
   describe("warnings", () => {
-    it("warns about reserved field names", () => {
+    it("does not warn about 'length' field names after ADR-058", () => {
       const source = `class MyStruct { int length; };`;
       const tree = TestHelpers.parseCpp(source);
       expect(tree).not.toBeNull();
       const result = CppResolver.resolve(tree!, "test.hpp", symbolTable);
 
-      expect(result.warnings).toHaveLength(1);
-      expect(result.warnings[0]).toContain("length");
-      expect(result.warnings[0]).toContain("MyStruct");
+      // No warnings since "length" is no longer reserved
+      expect(result.warnings).toHaveLength(0);
     });
   });
 });

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

@@ -749,17 +749,23 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private _isArrayAccessStringExpression(text: string): boolean {
     // Pattern: identifier[expression] or identifier[expression][expression]...
-    // BUT NOT if accessing .length/.capacity/.size (those return numbers, not strings)
+    // BUT NOT if accessing properties that return numbers, not strings
     const arrayAccessMatch = /^([a-zA-Z_]\w*)\[/.exec(text);
     if (!arrayAccessMatch) {
       return false;
     }
 
-    // ADR-045: String properties return numeric values, not strings
+    // ADR-045/ADR-058: String/array properties return numeric values, not strings
+    // ADR-058: .length deprecated, replaced by .bit_length, .byte_length,
+    // .element_count, .char_count
     if (
       text.endsWith(".length") ||
       text.endsWith(".capacity") ||
-      text.endsWith(".size")
+      text.endsWith(".size") ||
+      text.endsWith(".bit_length") ||
+      text.endsWith(".byte_length") ||
+      text.endsWith(".element_count") ||
+      text.endsWith(".char_count")
     ) {
       return false;
     }
@@ -2202,7 +2208,9 @@ export default class CodeGenerator implements IOrchestrator {
       const pathToUse =
         options?.sourceRelativePath ||
         CodeGenState.sourcePath.replace(/^.*[\\/]/, "");
-      const headerName = pathToUse.replace(/\.cnx$|\.cnext$/, ".h");
+      // Issue #933: Use .hpp extension in C++ mode to match header file
+      const ext = CodeGenState.cppMode ? ".hpp" : ".h";
+      const headerName = pathToUse.replace(/\.cnx$|\.cnext$/, ext);
       output.push(`#include "${headerName}"`, "");
       CodeGenState.selfIncludeAdded = true;
     }

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

@@ -61,15 +61,15 @@ describe("CodeGenerator Coverage Tests", () => {
   // NEW CODE IN PR: _isArrayAccessStringExpression (lines 811-852)
   // ==========================================================================
   describe("_isArrayAccessStringExpression() - PR new code", () => {
-    it("should return false for string property access (.length)", () => {
+    it("should return false for string property access (.char_count)", () => {
       const source = `
         string<32> name <- "test";
         void main() {
-          u32 len <- name.length;
+          u32 len <- name.char_count;
         }
       `;
       const { code } = setupGenerator(source);
-      // .length returns a number, not a string
+      // .char_count returns a number, not a string
       expect(code).toContain("strlen(name)");
     });
 

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

@@ -4719,11 +4719,11 @@ describe("CodeGenerator", () => {
     });
   });
 
-  describe("Array length", () => {
-    it("should generate array length using sizeof", () => {
+  describe("Array element_count", () => {
+    it("should generate array element_count using sizeof", () => {
       const source = `
         u32[10] data;
-        u32 len <- data.length;
+        u32 len <- data.element_count;
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -4735,7 +4735,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      // .length compiles to sizeof(arr)/sizeof(arr[0]) or constant
+      // .element_count compiles to sizeof(arr)/sizeof(arr[0]) or constant
       expect(code).toContain("len =");
     });
   });
@@ -9750,7 +9750,7 @@ describe("CodeGenerator", () => {
       it("should resolve string parameter", () => {
         const source = `
           void test(string<32> name) {
-            u32 len <- name.length;
+            u32 len <- name.char_count;
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -10273,12 +10273,12 @@ describe("CodeGenerator", () => {
       });
     });
 
-    describe("string capacity helpers", () => {
-      it("should get string capacity for global string variable", () => {
+    describe("string char_count helpers", () => {
+      it("should get string char_count for global string variable", () => {
         const source = `
           string<64> message <- "Hello World";
           void test() {
-            u32 cap <- message.length;
+            u32 cap <- message.char_count;
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -10294,12 +10294,12 @@ describe("CodeGenerator", () => {
         expect(code).toContain("message[65]");
       });
 
-      it("should get string capacity for scoped string variable", () => {
+      it("should get string char_count for scoped string variable", () => {
         const source = `
           scope Logger {
             string<128> buffer;
             public u32 getCapacity() {
-              return this.buffer.length;
+              return this.buffer.char_count;
             }
           }
         `;
@@ -13098,13 +13098,13 @@ describe("CodeGenerator", () => {
     });
 
     describe("strlen optimization (_setupLengthCache)", () => {
-      it("should optimize multiple .length accesses on same string", () => {
+      it("should optimize multiple .char_count accesses on same string", () => {
         const source = `
           void test() {
             string<32> name <- "hello";
-            u32 a <- name.length;
-            u32 b <- name.length;
-            u32 c <- name.length;
+            u32 a <- name.char_count;
+            u32 b <- name.char_count;
+            u32 c <- name.char_count;
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -13117,15 +13117,15 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Multiple .length accesses should be present
+        // Multiple .char_count accesses should be present
         expect(code).toContain("strlen");
       });
 
-      it("should generate proper strlen call for single length access", () => {
+      it("should generate proper strlen call for single char_count access", () => {
         const source = `
           void test() {
             string<32> msg <- "test";
-            u32 len <- msg.length;
+            u32 len <- msg.char_count;
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -13241,7 +13241,7 @@ describe("CodeGenerator", () => {
       it("should handle string parameter with capacity", () => {
         const source = `
           void greet(string<64> name) {
-            u32 len <- name.length;
+            u32 len <- name.char_count;
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -13726,8 +13726,8 @@ describe("CodeGenerator", () => {
         const source = `
           void test() {
             string<64> msg <- "hello world";
-            u32 len1 <- msg.length;
-            u32 len2 <- msg.length;
+            u32 len1 <- msg.char_count;
+            u32 len2 <- msg.char_count;
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -13743,12 +13743,12 @@ describe("CodeGenerator", () => {
         expect(code).toContain("strlen");
       });
 
-      it("should generate cache for multiple .length accesses", () => {
+      it("should generate cache for multiple .char_count accesses", () => {
         const source = `
           void test() {
             string<32> s <- "hello";
-            if (s.length > 0) {
-              u32 x <- s.length;
+            if (s.char_count > 0) {
+              u32 x <- s.char_count;
             }
           }
         `;
@@ -13762,15 +13762,15 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Should generate cache variable for repeated .length access
+        // Should generate cache variable for repeated .char_count access
         expect(code).toContain("strlen");
       });
 
-      it("should not cache for single .length access", () => {
+      it("should not cache for single .char_count access", () => {
         const source = `
           void test() {
             string<32> s <- "hello";
-            u32 len <- s.length;
+            u32 len <- s.char_count;
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);

package/src/transpiler/output/codegen/analysis/StringLengthCounter.ts

@@ -1,23 +1,24 @@
 /**
- * StringLengthCounter - Counts .length accesses on string variables
+ * StringLengthCounter - Counts .char_count accesses on string variables
  *
  * Issue #644: Extracted from CodeGenerator to reduce code duplication.
- * Used for strlen caching optimization - when a string's .length is accessed
+ * Used for strlen caching optimization - when a string's .char_count is accessed
  * multiple times, we cache the strlen result in a temp variable.
  *
  * Migrated to use CodeGenState instead of constructor DI.
+ * Updated for ADR-058: .length replaced with .char_count
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser";
 import CodeGenState from "../../../state/CodeGenState";
 
 /**
- * Counts .length accesses on string variables in an expression tree.
+ * Counts .char_count accesses on string variables in an expression tree.
  * This enables strlen caching optimization.
  */
 class StringLengthCounter {
   /**
-   * Count .length accesses in an expression.
+   * Count .char_count accesses in an expression.
    */
   static countExpression(ctx: Parser.ExpressionContext): Map<string, number> {
     const counts = new Map<string, number>();
@@ -26,7 +27,7 @@ class StringLengthCounter {
   }
 
   /**
-   * Count .length accesses in a block.
+   * Count .char_count accesses in a block.
    */
   static countBlock(ctx: Parser.BlockContext): Map<string, number> {
     const counts = new Map<string, number>();
@@ -37,7 +38,7 @@ class StringLengthCounter {
   }
 
   /**
-   * Count .length accesses in a block, adding to existing counts.
+   * Count .char_count accesses in a block, adding to existing counts.
    */
   static countBlockInto(
     ctx: Parser.BlockContext,
@@ -49,7 +50,7 @@ class StringLengthCounter {
   }
 
   /**
-   * Walk an expression tree, counting .length accesses.
+   * Walk an expression tree, counting .char_count accesses.
    * Uses generic traversal - only postfix expressions need special handling.
    */
   private static walkExpression(
@@ -177,7 +178,7 @@ class StringLengthCounter {
   }
 
   /**
-   * Walk a postfix expression - this is where we detect .length accesses.
+   * Walk a postfix expression - this is where we detect .char_count accesses.
    */
   private static walkPostfixExpr(
     ctx: Parser.PostfixExpressionContext,
@@ -187,11 +188,11 @@ class StringLengthCounter {
     const primaryId = primary.IDENTIFIER()?.getText();
     const ops = ctx.postfixOp();
 
-    // Check for pattern: identifier.length where identifier is a string
+    // Check for pattern: identifier.char_count where identifier is a string
     if (primaryId && ops.length > 0) {
       for (const op of ops) {
         const memberName = op.IDENTIFIER()?.getText();
-        if (memberName === "length") {
+        if (memberName === "char_count") {
           // Check if this is a string type
           const typeInfo = CodeGenState.getVariableTypeInfo(primaryId);
           if (typeInfo?.isString) {
@@ -213,7 +214,7 @@ class StringLengthCounter {
   }
 
   /**
-   * Walk a statement, counting .length accesses.
+   * Walk a statement, counting .char_count accesses.
    */
   private static walkStatement(
     ctx: Parser.StatementContext,

package/src/transpiler/output/codegen/analysis/__tests__/StringLengthCounter.test.ts

@@ -37,7 +37,7 @@ describe("StringLengthCounter", () => {
   });
 
   describe("countExpression", () => {
-    it("counts single .length access on string variable", () => {
+    it("counts single .char_count access on string variable", () => {
       CodeGenState.setVariableTypeInfo("myStr", {
         baseType: "char",
         bitWidth: 8,
@@ -47,13 +47,13 @@ describe("StringLengthCounter", () => {
         stringCapacity: 64,
       });
 
-      const expr = parseExpression("myStr.length");
+      const expr = parseExpression("myStr.char_count");
       const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("myStr")).toBe(1);
     });
 
-    it("counts multiple .length accesses on same variable", () => {
+    it("counts multiple .char_count accesses on same variable", () => {
       CodeGenState.setVariableTypeInfo("str", {
         baseType: "char",
         bitWidth: 8,
@@ -63,14 +63,14 @@ describe("StringLengthCounter", () => {
         stringCapacity: 32,
       });
 
-      // Expression: str.length + str.length
-      const expr = parseExpression("str.length + str.length");
+      // Expression: str.char_count + str.char_count
+      const expr = parseExpression("str.char_count + str.char_count");
       const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("str")).toBe(2);
     });
 
-    it("counts .length accesses on different string variables", () => {
+    it("counts .char_count accesses on different string variables", () => {
       CodeGenState.setVariableTypeInfo("a", {
         baseType: "char",
         bitWidth: 8,
@@ -88,14 +88,14 @@ describe("StringLengthCounter", () => {
         stringCapacity: 16,
       });
 
-      const expr = parseExpression("a.length + b.length");
+      const expr = parseExpression("a.char_count + b.char_count");
       const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("a")).toBe(1);
       expect(counts.get("b")).toBe(1);
     });
 
-    it("ignores .length on non-string variables", () => {
+    it("ignores .char_count on non-string variables", () => {
       CodeGenState.setVariableTypeInfo("arr", {
         baseType: "u8",
         bitWidth: 8,
@@ -104,7 +104,7 @@ describe("StringLengthCounter", () => {
         arrayDimensions: [10],
       });
 
-      const expr = parseExpression("arr.length");
+      const expr = parseExpression("arr.char_count");
       const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("arr")).toBeUndefined();
@@ -126,7 +126,7 @@ describe("StringLengthCounter", () => {
 
     it("handles unknown variables gracefully", () => {
       // No type registered for "unknown"
-      const expr = parseExpression("unknown.length");
+      const expr = parseExpression("unknown.char_count");
       const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.size).toBe(0);
@@ -134,7 +134,7 @@ describe("StringLengthCounter", () => {
   });
 
   describe("countBlock", () => {
-    it("counts .length accesses across multiple statements", () => {
+    it("counts .char_count accesses across multiple statements", () => {
       CodeGenState.setVariableTypeInfo("msg", {
         baseType: "char",
         bitWidth: 8,
@@ -145,15 +145,15 @@ describe("StringLengthCounter", () => {
       });
 
       const block = parseBlock(`
-        u32 len <- msg.length;
-        u32 doubled <- msg.length * 2;
+        u32 len <- msg.char_count;
+        u32 doubled <- msg.char_count * 2;
       `);
       const counts = StringLengthCounter.countBlock(block);
 
       expect(counts.get("msg")).toBe(2);
     });
 
-    it("counts .length in assignment statements", () => {
+    it("counts .char_count in assignment statements", () => {
       CodeGenState.setVariableTypeInfo("text", {
         baseType: "char",
         bitWidth: 8,
@@ -165,7 +165,7 @@ describe("StringLengthCounter", () => {
 
       const block = parseBlock(`
         u32 x;
-        x <- text.length;
+        x <- text.char_count;
       `);
       const counts = StringLengthCounter.countBlock(block);
 
@@ -197,8 +197,8 @@ describe("StringLengthCounter", () => {
       counts.set("s1", 1);
 
       const block = parseBlock(`
-        u32 a <- s1.length;
-        u32 b <- s2.length;
+        u32 a <- s1.char_count;
+        u32 b <- s2.char_count;
       `);
       StringLengthCounter.countBlockInto(block, counts);
 
@@ -208,7 +208,7 @@ describe("StringLengthCounter", () => {
   });
 
   describe("nested expressions", () => {
-    it("counts .length in ternary expressions", () => {
+    it("counts .char_count in ternary expressions", () => {
       CodeGenState.setVariableTypeInfo("str", {
         baseType: "char",
         bitWidth: 8,
@@ -218,13 +218,13 @@ describe("StringLengthCounter", () => {
         stringCapacity: 64,
       });
 
-      const expr = parseExpression("(str.length > 0) ? str.length : 0");
+      const expr = parseExpression("(str.char_count > 0) ? str.char_count : 0");
       const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("str")).toBe(2);
     });
 
-    it("counts .length in comparison expressions", () => {
+    it("counts .char_count in comparison expressions", () => {
       CodeGenState.setVariableTypeInfo("name", {
         baseType: "char",
         bitWidth: 8,
@@ -234,7 +234,7 @@ describe("StringLengthCounter", () => {
         stringCapacity: 50,
       });
 
-      const expr = parseExpression("name.length = 10");
+      const expr = parseExpression("name.char_count = 10");
       const counts = StringLengthCounter.countExpression(expr);
 
       expect(counts.get("name")).toBe(1);