c-next 0.1.64 → 0.1.66

package/src/transpiler/output/codegen/generators/expressions/__tests__/PostfixExpressionGenerator.test.ts

@@ -2071,4 +2071,823 @@ describe("PostfixExpressionGenerator", () => {
       expect(result.code).toBe("matrix[0][1]");
     });
   });
+
+  // ========================================================================
+  // ADR-058: Explicit Length Properties
+  // ========================================================================
+
+  describe(".bit_length property (ADR-058)", () => {
+    it("returns bit width for integer type", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "val",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: false,
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("32");
+    });
+
+    it("returns 32 for enum type", () => {
+      const symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
+      });
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "color",
+          {
+            baseType: "Color",
+            bitWidth: 32,
+            isArray: false,
+            isConst: false,
+            isEnum: true,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("color", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ symbols, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "color",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("32");
+    });
+
+    it("returns total bits for array type", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "arr",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: true,
+            arrayDimensions: [16],
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("arr", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "arr",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("512"); // 16 * 32 = 512
+    });
+
+    it("returns buffer bits for string type", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "str",
+          {
+            baseType: "char",
+            bitWidth: 8,
+            isArray: false,
+            isConst: false,
+            isString: true,
+            stringCapacity: 64,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("str", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "str",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("520"); // (64 + 1) * 8 = 520
+    });
+  });
+
+  describe(".byte_length property (ADR-058)", () => {
+    it("returns byte size for integer type", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "val",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: false,
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({ identifier: "byte_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("4"); // 32 / 8 = 4
+    });
+
+    it("returns total bytes for array type", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "arr",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: true,
+            arrayDimensions: [16],
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("arr", [
+        createMockPostfixOp({ identifier: "byte_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "arr",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("64"); // 16 * 4 = 64
+    });
+
+    it("returns buffer bytes for string type", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "str",
+          {
+            baseType: "char",
+            bitWidth: 8,
+            isArray: false,
+            isConst: false,
+            isString: true,
+            stringCapacity: 64,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("str", [
+        createMockPostfixOp({ identifier: "byte_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "str",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("65"); // 64 + 1 = 65
+    });
+  });
+
+  describe(".element_count property (ADR-058)", () => {
+    it("returns element count for array type", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "arr",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: true,
+            arrayDimensions: [16],
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("arr", [
+        createMockPostfixOp({ identifier: "element_count" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "arr",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("16");
+    });
+
+    it("returns argc for main args", () => {
+      const ctx = createMockPostfixExpressionContext("args", [
+        createMockPostfixOp({ identifier: "element_count" }),
+      ]);
+      const input = createMockInput();
+      const state = createMockState({ mainArgsName: "args" });
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "args",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("argc");
+    });
+
+    it("throws error for non-array type", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "val",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: false,
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({ identifier: "element_count" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow(".element_count is only available on arrays");
+    });
+  });
+
+  describe(".char_count property (ADR-058)", () => {
+    it("returns strlen for string type", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "str",
+          {
+            baseType: "char",
+            bitWidth: 8,
+            isArray: false,
+            isConst: false,
+            isString: true,
+            stringCapacity: 64,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("str", [
+        createMockPostfixOp({ identifier: "char_count" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "str",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("strlen(str)");
+      expect(result.effects).toContainEqual({
+        type: "include",
+        header: "string",
+      });
+    });
+
+    it("throws error for non-string type", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "val",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: false,
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({ identifier: "char_count" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow(".char_count is only available on strings");
+    });
+
+    it("throws error for args", () => {
+      const ctx = createMockPostfixExpressionContext("args", [
+        createMockPostfixOp({ identifier: "char_count" }),
+      ]);
+      const input = createMockInput();
+      const state = createMockState({ mainArgsName: "args" });
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "args",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow(".char_count is only available on strings");
+    });
+  });
+
+  describe("explicit length edge cases (ADR-058)", () => {
+    it("returns dynamic dimension comment for array with C macro size", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "arr",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: true,
+            arrayDimensions: ["BUFFER_SIZE" as unknown as number], // C macro
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("arr", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "arr",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toContain("dynamic dimension BUFFER_SIZE");
+    });
+
+    it("returns C macro name for element_count with dynamic dimension", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "arr",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: true,
+            arrayDimensions: ["BUFFER_SIZE" as unknown as number], // C macro
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("arr", [
+        createMockPostfixOp({ identifier: "element_count" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "arr",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("BUFFER_SIZE");
+    });
+
+    it("throws error for bit_length on args", () => {
+      const ctx = createMockPostfixExpressionContext("args", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput();
+      const state = createMockState({ mainArgsName: "args" });
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "args",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow(".bit_length is not supported on 'args'");
+    });
+
+    it("throws error for byte_length on args", () => {
+      const ctx = createMockPostfixExpressionContext("args", [
+        createMockPostfixOp({ identifier: "byte_length" }),
+      ]);
+      const input = createMockInput();
+      const state = createMockState({ mainArgsName: "args" });
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "args",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow(".byte_length is not supported on 'args'");
+    });
+
+    it("throws error for unknown type bit_length", () => {
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry: new Map() });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow("type not found in registry");
+    });
+
+    it("throws error for unknown type byte_length", () => {
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({ identifier: "byte_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry: new Map() });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow("type not found in registry");
+    });
+
+    it("throws error for unknown type element_count", () => {
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({ identifier: "element_count" }),
+      ]);
+      const input = createMockInput({ typeRegistry: new Map() });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow("type not found in registry");
+    });
+
+    it("throws error for string without capacity", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "str",
+          {
+            baseType: "char",
+            bitWidth: 8,
+            isArray: false,
+            isConst: false,
+            isString: true,
+            // No stringCapacity set
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("str", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "str",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow("unknown capacity");
+    });
+
+    it("handles struct field bit_length for string member", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "obj",
+          {
+            baseType: "MyStruct",
+            bitWidth: 0,
+            isArray: false,
+            isConst: false,
+          },
+        ],
+      ]);
+      const symbols = createMockSymbols({
+        knownStructs: new Set(["MyStruct"]),
+      });
+      const ctx = createMockPostfixExpressionContext("obj", [
+        createMockPostfixOp({ identifier: "name" }),
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ symbols, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "obj",
+        isKnownStruct: (name) => name === "MyStruct",
+        getStructFieldInfo: () => ({
+          type: "string<32>",
+        }),
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("264"); // (32 + 1) * 8 = 264
+    });
+
+    it("handles struct field byte_length", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "obj",
+          {
+            baseType: "MyStruct",
+            bitWidth: 0,
+            isArray: false,
+            isConst: false,
+          },
+        ],
+      ]);
+      const symbols = createMockSymbols({
+        knownStructs: new Set(["MyStruct"]),
+      });
+      const ctx = createMockPostfixExpressionContext("obj", [
+        createMockPostfixOp({ identifier: "value" }),
+        createMockPostfixOp({ identifier: "byte_length" }),
+      ]);
+      const input = createMockInput({ symbols, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "obj",
+        isKnownStruct: (name) => name === "MyStruct",
+        getStructFieldInfo: () => ({
+          type: "u16",
+        }),
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("2"); // 16 / 8 = 2
+    });
+
+    it("handles struct field element_count for array member", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "obj",
+          {
+            baseType: "MyStruct",
+            bitWidth: 0,
+            isArray: false,
+            isConst: false,
+          },
+        ],
+      ]);
+      const symbols = createMockSymbols({
+        knownStructs: new Set(["MyStruct"]),
+      });
+      const ctx = createMockPostfixExpressionContext("obj", [
+        createMockPostfixOp({ identifier: "data" }),
+        createMockPostfixOp({ identifier: "element_count" }),
+      ]);
+      const input = createMockInput({ symbols, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "obj",
+        isKnownStruct: (name) => name === "MyStruct",
+        getStructFieldInfo: () => ({
+          type: "u8",
+          dimensions: [64],
+        }),
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("64");
+    });
+
+    it("throws for struct field element_count on non-array member", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "obj",
+          {
+            baseType: "MyStruct",
+            bitWidth: 0,
+            isArray: false,
+            isConst: false,
+          },
+        ],
+      ]);
+      const symbols = createMockSymbols({
+        knownStructs: new Set(["MyStruct"]),
+      });
+      const ctx = createMockPostfixExpressionContext("obj", [
+        createMockPostfixOp({ identifier: "value" }),
+        createMockPostfixOp({ identifier: "element_count" }),
+      ]);
+      const input = createMockInput({ symbols, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "obj",
+        isKnownStruct: (name) => name === "MyStruct",
+        getStructFieldInfo: () => ({
+          type: "u32",
+        }),
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow(".element_count is only available on arrays");
+    });
+
+    it("handles struct field char_count for string member", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "obj",
+          {
+            baseType: "MyStruct",
+            bitWidth: 0,
+            isArray: false,
+            isConst: false,
+          },
+        ],
+      ]);
+      const symbols = createMockSymbols({
+        knownStructs: new Set(["MyStruct"]),
+      });
+      const ctx = createMockPostfixExpressionContext("obj", [
+        createMockPostfixOp({ identifier: "name" }),
+        createMockPostfixOp({ identifier: "char_count" }),
+      ]);
+      const input = createMockInput({ symbols, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "obj",
+        isKnownStruct: (name) => name === "MyStruct",
+        getStructFieldInfo: () => ({
+          type: "string<32>",
+        }),
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("strlen(obj.name)");
+    });
+
+    it("throws for struct field char_count on non-string member", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "obj",
+          {
+            baseType: "MyStruct",
+            bitWidth: 0,
+            isArray: false,
+            isConst: false,
+          },
+        ],
+      ]);
+      const symbols = createMockSymbols({
+        knownStructs: new Set(["MyStruct"]),
+      });
+      const ctx = createMockPostfixExpressionContext("obj", [
+        createMockPostfixOp({ identifier: "value" }),
+        createMockPostfixOp({ identifier: "char_count" }),
+      ]);
+      const input = createMockInput({ symbols, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "obj",
+        isKnownStruct: (name) => name === "MyStruct",
+        getStructFieldInfo: () => ({
+          type: "u32",
+        }),
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow(".char_count is only available on strings");
+    });
+
+    it("throws error for unknown type char_count", () => {
+      const ctx = createMockPostfixExpressionContext("val", [
+        createMockPostfixOp({ identifier: "char_count" }),
+      ]);
+      const input = createMockInput({ typeRegistry: new Map() });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "val",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow("type not found in registry");
+    });
+
+    it("throws error for array with unknown dimensions for element_count", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "arr",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: true,
+            arrayDimensions: [], // Empty dimensions
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("arr", [
+        createMockPostfixOp({ identifier: "element_count" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "arr",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow("unknown dimensions");
+    });
+
+    it("throws error for array with unknown dimensions for bit_length", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "arr",
+          {
+            baseType: "u32",
+            bitWidth: 32,
+            isArray: true,
+            arrayDimensions: [], // Empty dimensions
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("arr", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "arr",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow("unknown dimensions");
+    });
+
+    it("handles enum array bit_length", () => {
+      const symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
+      });
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "colors",
+          {
+            baseType: "Color",
+            bitWidth: 0, // Not set, should infer from isEnum
+            isArray: true,
+            arrayDimensions: [4],
+            isConst: false,
+            isEnum: true,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("colors", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ symbols, typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "colors",
+      });
+
+      const result = generatePostfixExpression(ctx, input, state, orchestrator);
+      expect(result.code).toBe("128"); // 4 * 32 = 128
+    });
+
+    it("throws error for unsupported element type in array", () => {
+      const typeRegistry = new Map<string, TTypeInfo>([
+        [
+          "arr",
+          {
+            baseType: "void", // Unsupported type
+            bitWidth: 0,
+            isArray: true,
+            arrayDimensions: [4],
+            isConst: false,
+          },
+        ],
+      ]);
+      const ctx = createMockPostfixExpressionContext("arr", [
+        createMockPostfixOp({ identifier: "bit_length" }),
+      ]);
+      const input = createMockInput({ typeRegistry });
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        generatePrimaryExpr: () => "arr",
+      });
+
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow("unsupported element type");
+    });
+  });
 });