c-next 0.1.61 → 0.1.63

package/src/transpiler/output/codegen/resolution/__tests__/SizeofResolver.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Tests for SizeofResolver - sizeof expression generation
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import SizeofResolver from "../SizeofResolver";
+import CodeGenState from "../../CodeGenState";
+
+describe("SizeofResolver", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
+  describe("sizeofParameter", () => {
+    it("throws E0601 for array parameter", () => {
+      // Set up parameter info indicating array
+      CodeGenState.currentParameters.set("arr", {
+        name: "arr",
+        baseType: "u32",
+        isArray: true,
+        isStruct: false,
+        isConst: false,
+        isCallback: false,
+        isString: false,
+      });
+
+      const mockCallbacks = {
+        generateType: vi.fn(),
+        generateExpression: vi.fn(),
+        hasSideEffects: vi.fn().mockReturnValue(false),
+      };
+
+      // Create a mock context for sizeof(arr)
+      const mockTypeCtx = {
+        qualifiedType: () => null,
+        userType: () => ({ getText: () => "arr" }),
+        getText: () => "arr",
+      };
+
+      const mockCtx = {
+        type: () => mockTypeCtx,
+        expression: () => null,
+      };
+
+      expect(() =>
+        SizeofResolver.generate(mockCtx as never, mockCallbacks),
+      ).toThrow("Error[E0601]");
+    });
+
+    it("generates dereference for pass-by-reference parameter", () => {
+      // Non-array, non-callback, non-struct parameter is pass-by-reference
+      CodeGenState.currentParameters.set("value", {
+        name: "value",
+        baseType: "u32",
+        isArray: false,
+        isStruct: false,
+        isConst: false,
+        isCallback: false,
+        isString: false,
+      });
+
+      const mockCallbacks = {
+        generateType: vi.fn(),
+        generateExpression: vi.fn(),
+        hasSideEffects: vi.fn().mockReturnValue(false),
+      };
+
+      const mockTypeCtx = {
+        qualifiedType: () => null,
+        userType: () => ({ getText: () => "value" }),
+        getText: () => "value",
+      };
+
+      const mockCtx = {
+        type: () => mockTypeCtx,
+        expression: () => null,
+      };
+
+      const result = SizeofResolver.generate(mockCtx as never, mockCallbacks);
+
+      expect(result).toBe("sizeof(*value)");
+    });
+  });
+
+  describe("sizeofQualifiedType", () => {
+    it("handles struct.member access for local variable", () => {
+      CodeGenState.localVariables.add("myStruct");
+
+      const mockCallbacks = {
+        generateType: vi.fn(),
+        generateExpression: vi.fn(),
+        hasSideEffects: vi.fn().mockReturnValue(false),
+      };
+
+      const mockQualifiedCtx = {
+        IDENTIFIER: () => [
+          { getText: () => "myStruct" },
+          { getText: () => "field" },
+        ],
+      };
+
+      const mockTypeCtx = {
+        qualifiedType: () => mockQualifiedCtx,
+        userType: () => null,
+        getText: () => "myStruct.field",
+      };
+
+      const mockCtx = {
+        type: () => mockTypeCtx,
+        expression: () => null,
+      };
+
+      const result = SizeofResolver.generate(mockCtx as never, mockCallbacks);
+
+      expect(result).toBe("sizeof(myStruct.field)");
+    });
+
+    it("handles struct parameter with arrow notation", () => {
+      CodeGenState.currentParameters.set("param", {
+        name: "param",
+        baseType: "MyStruct",
+        isArray: false,
+        isStruct: true,
+        isConst: false,
+        isCallback: false,
+        isString: false,
+      });
+
+      const mockCallbacks = {
+        generateType: vi.fn(),
+        generateExpression: vi.fn(),
+        hasSideEffects: vi.fn().mockReturnValue(false),
+      };
+
+      const mockQualifiedCtx = {
+        IDENTIFIER: () => [
+          { getText: () => "param" },
+          { getText: () => "field" },
+        ],
+      };
+
+      const mockTypeCtx = {
+        qualifiedType: () => mockQualifiedCtx,
+        userType: () => null,
+        getText: () => "param.field",
+      };
+
+      const mockCtx = {
+        type: () => mockTypeCtx,
+        expression: () => null,
+      };
+
+      const result = SizeofResolver.generate(mockCtx as never, mockCallbacks);
+
+      expect(result).toBe("sizeof(param->field)");
+    });
+
+    it("handles non-struct parameter with dot notation", () => {
+      CodeGenState.currentParameters.set("param", {
+        name: "param",
+        baseType: "MyStruct",
+        isArray: false,
+        isStruct: false,
+        isConst: false,
+        isCallback: false,
+        isString: false,
+      });
+
+      const mockCallbacks = {
+        generateType: vi.fn(),
+        generateExpression: vi.fn(),
+        hasSideEffects: vi.fn().mockReturnValue(false),
+      };
+
+      const mockQualifiedCtx = {
+        IDENTIFIER: () => [
+          { getText: () => "param" },
+          { getText: () => "field" },
+        ],
+      };
+
+      const mockTypeCtx = {
+        qualifiedType: () => mockQualifiedCtx,
+        userType: () => null,
+        getText: () => "param.field",
+      };
+
+      const mockCtx = {
+        type: () => mockTypeCtx,
+        expression: () => null,
+      };
+
+      const result = SizeofResolver.generate(mockCtx as never, mockCallbacks);
+
+      expect(result).toBe("sizeof(param.field)");
+    });
+  });
+
+  // Note: sizeofExpression with side effects is tested via integration tests
+  // The mock structure required is too complex for unit testing
+});

package/src/transpiler/output/codegen/types/IArrayAccessDeps.ts

@@ -0,0 +1,23 @@
+/**
+ * Dependencies required by ArrayAccessHelper for code generation.
+ * Allows the helper to request includes and access state without
+ * direct coupling to CodeGenerator.
+ */
+import TIncludeHeader from "../generators/TIncludeHeader";
+
+type IArrayAccessDeps = {
+  /** Generate a bit mask for the given width */
+  generateBitMask(width: string, is64Bit?: boolean): string;
+  /** Request an include header */
+  requireInclude(header: TIncludeHeader): void;
+  /** Check if we're in a function body */
+  isInFunctionBody(): boolean;
+  /** Register a float shadow variable, returns true if newly registered */
+  registerFloatShadow(shadowName: string, shadowType: string): boolean;
+  /** Check if shadow is current (already synced) */
+  isShadowCurrent(shadowName: string): boolean;
+  /** Mark shadow as current */
+  markShadowCurrent(shadowName: string): void;
+};
+
+export default IArrayAccessDeps;

package/src/transpiler/output/codegen/types/IArrayAccessInfo.ts

@@ -0,0 +1,26 @@
+/**
+ * Intermediate representation for array access operations.
+ * Decouples code generation from ANTLR parser contexts.
+ */
+import TTypeInfo from "./TTypeInfo";
+
+type IArrayAccessInfo = {
+  /** The raw identifier name from source */
+  rawName: string;
+  /** The resolved name (may include dereference like `(*param)`) */
+  resolvedName: string;
+  /** The access type */
+  accessType: "single-index" | "bit-range";
+  /** Index expression as generated C code (for single-index) */
+  indexExpr?: string;
+  /** For bit ranges: start position */
+  startExpr?: string;
+  /** For bit ranges: width */
+  widthExpr?: string;
+  /** Type info for the variable being accessed */
+  typeInfo?: TTypeInfo;
+  /** Source line for error messages */
+  line: number;
+};
+
+export default IArrayAccessInfo;

package/src/transpiler/output/codegen/types/IMemberSeparatorDeps.ts

@@ -11,6 +11,13 @@ interface IMemberSeparatorDeps {
   /** Validate cross-scope visibility and throw if not visible */
   validateCrossScopeVisibility(scopeName: string, memberName: string): void;
 
+  /** Validate register access from inside a scope requires global. prefix */
+  validateRegisterAccess(
+    registerName: string,
+    memberName: string,
+    hasGlobal: boolean,
+  ): void;
+
   /** Get struct param separator based on C/C++ mode */
   getStructParamSeparator(): string;
 }

package/src/transpiler/output/codegen/utils/CodegenParserUtils.ts

@@ -0,0 +1,98 @@
+/**
+ * Parser utilities specific to code generation.
+ *
+ * These utilities depend on ANTLR parser types and are used by CodeGenerator.
+ * Separated from src/utils/ParserUtils.ts to avoid circular dependencies.
+ */
+
+import { ParserRuleContext, TerminalNode } from "antlr4ng";
+import * as Parser from "../../../logic/parser/grammar/CNextParser";
+import ExpressionUnwrapper from "./ExpressionUnwrapper";
+
+/**
+ * Static utility methods for parser context operations in code generation.
+ */
+class CodegenParserUtils {
+  /**
+   * Extract operators from parse tree children in order.
+   *
+   * When parsing expressions like "a + b - c", ANTLR creates children
+   * with operands interleaved: [a, +, b, -, c]. This method extracts
+   * just the operators as terminal nodes.
+   *
+   * Note: Using children.filter() loses operator ordering when operators
+   * are detected using text.includes(), so we iterate explicitly.
+   *
+   * @param ctx - The parser rule context containing operands and operators
+   * @returns Array of operator strings in the order they appear
+   */
+  static getOperatorsFromChildren(ctx: ParserRuleContext): string[] {
+    const operators: string[] = [];
+    for (const child of ctx.children) {
+      if (child instanceof TerminalNode) {
+        operators.push(child.getText());
+      }
+    }
+    return operators;
+  }
+
+  /**
+   * Check if this is the main function with command-line args parameter.
+   * Supports: u8 args[][] (legacy) or string args[] (preferred)
+   *
+   * @param name - Function name
+   * @param paramList - Parameter list context
+   * @returns true if this is main with args parameter
+   */
+  static isMainFunctionWithArgs(
+    name: string,
+    paramList: Parser.ParameterListContext | null,
+  ): boolean {
+    if (name !== "main" || !paramList) {
+      return false;
+    }
+
+    const params = paramList.parameter();
+    if (params.length !== 1) {
+      return false;
+    }
+
+    const param = params[0];
+    const typeCtx = param.type();
+    const dims = param.arrayDimension();
+
+    // Check for string args[] (preferred - array of strings)
+    if (typeCtx.stringType() && dims.length === 1) {
+      return true;
+    }
+
+    // Check for u8 args[][] (legacy - 2D array of bytes)
+    const type = typeCtx.getText();
+    return (type === "u8" || type === "i8") && dims.length === 2;
+  }
+
+  /**
+   * Extract a simple identifier from an expression, if it is one.
+   * Returns null for complex expressions (binary ops, function calls, etc.)
+   *
+   * A "simple identifier" is an expression that is just a variable name
+   * with no operators, member access, or array indexing.
+   *
+   * @param ctx - The expression context to analyze
+   * @returns The identifier string, or null if not a simple identifier
+   */
+  static getSimpleIdentifier(ctx: Parser.ExpressionContext): string | null {
+    const postfix = ExpressionUnwrapper.getPostfixExpression(ctx);
+    if (!postfix) return null;
+
+    // Has postfix operators like . or [] - not a simple identifier
+    if (postfix.postfixOp().length !== 0) return null;
+
+    const primary = postfix.primaryExpression();
+    if (!primary.IDENTIFIER()) return null;
+
+    return primary.IDENTIFIER()!.getText();
+  }
+}
+
+export default CodegenParserUtils;

package/src/transpiler/output/codegen/utils/ExpressionUnwrapper.ts

@@ -62,17 +62,14 @@ class ExpressionUnwrapper {
   }
 
   /**
-   * Navigate from ExpressionContext to PostfixExpressionContext.
-   * Returns null if the expression has multiple terms at any level
-   * (indicating binary operations).
+   * Navigate from ExpressionContext to UnaryExpressionContext.
+   * Common helper for getPostfixExpression and getUnaryExpression.
    *
-   * Use this when you need to access the postfix expression for:
-   * - Getting the primary expression (identifier, literal)
-   * - Checking postfix operators (member access, array indexing)
+   * Returns null if expression has multiple terms at any level.
    */
-  static getPostfixExpression(
+  private static navigateToUnary(
     ctx: Parser.ExpressionContext,
-  ): Parser.PostfixExpressionContext | null {
+  ): Parser.UnaryExpressionContext | null {
     const shift = this.navigateToShift(ctx);
     if (!shift) return null;
 
@@ -84,9 +81,23 @@ class ExpressionUnwrapper {
     const mult = add.multiplicativeExpression()[0];
     if (mult.unaryExpression().length !== 1) return null;
 
-    const unary = mult.unaryExpression()[0];
-    if (!unary.postfixExpression()) return null;
+    return mult.unaryExpression()[0];
+  }
 
+  /**
+   * Navigate from ExpressionContext to PostfixExpressionContext.
+   * Returns null if the expression has multiple terms at any level
+   * (indicating binary operations).
+   *
+   * Use this when you need to access the postfix expression for:
+   * - Getting the primary expression (identifier, literal)
+   * - Checking postfix operators (member access, array indexing)
+   */
+  static getPostfixExpression(
+    ctx: Parser.ExpressionContext,
+  ): Parser.PostfixExpressionContext | null {
+    const unary = this.navigateToUnary(ctx);
+    if (!unary?.postfixExpression()) return null;
     return unary.postfixExpression()!;
   }
 
@@ -99,18 +110,7 @@ class ExpressionUnwrapper {
   static getUnaryExpression(
     ctx: Parser.ExpressionContext,
   ): Parser.UnaryExpressionContext | null {
-    const shift = this.navigateToShift(ctx);
-    if (!shift) return null;
-
-    if (shift.additiveExpression().length !== 1) return null;
-
-    const add = shift.additiveExpression()[0];
-    if (add.multiplicativeExpression().length !== 1) return null;
-
-    const mult = add.multiplicativeExpression()[0];
-    if (mult.unaryExpression().length !== 1) return null;
-
-    return mult.unaryExpression()[0];
+    return this.navigateToUnary(ctx);
   }
 
   /**

package/src/transpiler/output/codegen/utils/__tests__/CodegenParserUtils.test.ts

@@ -0,0 +1,228 @@
+/**
+ * Unit tests for CodegenParserUtils
+ */
+
+import { describe, expect, it } from "vitest";
+import CodegenParserUtils from "../CodegenParserUtils";
+import CNextSourceParser from "../../../../logic/parser/CNextSourceParser";
+import * as Parser from "../../../../logic/parser/grammar/CNextParser";
+
+/**
+ * Helper to parse and get the expression from a variable declaration
+ */
+function parseExpression(exprSource: string): Parser.ExpressionContext {
+  const source = `void main() { u32 x <- ${exprSource}; }`;
+  const { tree, errors } = CNextSourceParser.parse(source);
+
+  if (errors.length > 0) {
+    throw new Error(`Parse failed: ${errors.map((e) => e.message).join(", ")}`);
+  }
+
+  // Navigate to the expression in the AST
+  for (const decl of tree.declaration()) {
+    const funcDecl = decl.functionDeclaration();
+    if (funcDecl?.IDENTIFIER().getText() === "main") {
+      const block = funcDecl.block();
+      const stmt = block?.statement()[0];
+      const varDecl = stmt?.variableDeclaration();
+      const expr = varDecl?.expression();
+      if (expr) return expr;
+    }
+  }
+
+  throw new Error("Could not find expression in parsed tree");
+}
+
+/**
+ * Helper to drill down to additive expression level
+ * Follows the same pattern as ExpressionUnwrapper for navigating expression tree
+ */
+function getAdditiveFromExpr(
+  expr: Parser.ExpressionContext,
+): Parser.AdditiveExpressionContext | null {
+  const ternary = expr.ternaryExpression();
+  if (!ternary) return null;
+
+  const orExprs = ternary.orExpression();
+  if (orExprs.length !== 1) return null;
+
+  const or = orExprs[0];
+  const and = or.andExpression()[0];
+  if (!and) return null;
+
+  const eq = and.equalityExpression()[0];
+  if (!eq) return null;
+
+  const rel = eq.relationalExpression()[0];
+  if (!rel) return null;
+
+  const bor = rel.bitwiseOrExpression()[0];
+  if (!bor) return null;
+
+  const bxor = bor.bitwiseXorExpression()[0];
+  if (!bxor) return null;
+
+  const band = bxor.bitwiseAndExpression()[0];
+  if (!band) return null;
+
+  const shift = band.shiftExpression()[0];
+  if (!shift) return null;
+
+  return shift.additiveExpression()[0] ?? null;
+}
+
+/**
+ * Helper to parse a function declaration and get its parameter list
+ */
+function parseFunctionDeclaration(source: string): {
+  name: string;
+  paramList: Parser.ParameterListContext | null;
+} {
+  const { tree, errors } = CNextSourceParser.parse(source);
+
+  if (errors.length > 0) {
+    throw new Error(`Parse failed: ${errors.map((e) => e.message).join(", ")}`);
+  }
+
+  for (const decl of tree.declaration()) {
+    const funcDecl = decl.functionDeclaration();
+    if (funcDecl) {
+      return {
+        name: funcDecl.IDENTIFIER().getText(),
+        paramList: funcDecl.parameterList() ?? null,
+      };
+    }
+  }
+
+  throw new Error("Could not find function declaration in parsed tree");
+}
+
+describe("CodegenParserUtils", () => {
+  describe("getOperatorsFromChildren", () => {
+    it("extracts operators from additive expression", () => {
+      const expr = parseExpression("1 + 2 - 3");
+      const additive = getAdditiveFromExpr(expr);
+      expect(additive).not.toBeNull();
+
+      const operators = CodegenParserUtils.getOperatorsFromChildren(additive!);
+      expect(operators).toEqual(["+", "-"]);
+    });
+
+    it("extracts operators from multiplicative expression", () => {
+      const expr = parseExpression("2 * 3 / 4");
+      const additive = getAdditiveFromExpr(expr);
+      const mult = additive?.multiplicativeExpression(0);
+      expect(mult).toBeDefined();
+
+      const operators = CodegenParserUtils.getOperatorsFromChildren(mult!);
+      expect(operators).toEqual(["*", "/"]);
+    });
+
+    it("returns empty array for expression with no operators", () => {
+      // For a simple expression like "42", the additive expression has only one
+      // multiplicative child (no operators between terms)
+      const expr = parseExpression("42");
+      const additive = getAdditiveFromExpr(expr);
+      expect(additive).not.toBeNull();
+
+      // Additive expression with single term has no terminal operators
+      const operators = CodegenParserUtils.getOperatorsFromChildren(additive!);
+      expect(operators).toEqual([]);
+    });
+  });
+
+  describe("getSimpleIdentifier", () => {
+    it("returns identifier for simple variable", () => {
+      const expr = parseExpression("myVar");
+      expect(CodegenParserUtils.getSimpleIdentifier(expr)).toBe("myVar");
+    });
+
+    it("returns null for member access", () => {
+      const expr = parseExpression("obj.field");
+      expect(CodegenParserUtils.getSimpleIdentifier(expr)).toBeNull();
+    });
+
+    it("returns null for array access", () => {
+      const expr = parseExpression("arr[0]");
+      expect(CodegenParserUtils.getSimpleIdentifier(expr)).toBeNull();
+    });
+
+    it("returns null for binary expression", () => {
+      const expr = parseExpression("a + b");
+      expect(CodegenParserUtils.getSimpleIdentifier(expr)).toBeNull();
+    });
+
+    it("returns null for function call", () => {
+      const expr = parseExpression("foo()");
+      expect(CodegenParserUtils.getSimpleIdentifier(expr)).toBeNull();
+    });
+
+    it("returns null for literal", () => {
+      const expr = parseExpression("42");
+      expect(CodegenParserUtils.getSimpleIdentifier(expr)).toBeNull();
+    });
+  });
+
+  describe("isMainFunctionWithArgs", () => {
+    it("returns true for main with string args[]", () => {
+      const { name, paramList } = parseFunctionDeclaration(
+        "void main(string args[]) {}",
+      );
+      expect(CodegenParserUtils.isMainFunctionWithArgs(name, paramList)).toBe(
+        true,
+      );
+    });
+
+    it("returns true for main with u8 args[][]", () => {
+      const { name, paramList } = parseFunctionDeclaration(
+        "void main(u8 args[][]) {}",
+      );
+      expect(CodegenParserUtils.isMainFunctionWithArgs(name, paramList)).toBe(
+        true,
+      );
+    });
+
+    it("returns true for main with i8 args[][]", () => {
+      const { name, paramList } = parseFunctionDeclaration(
+        "void main(i8 args[][]) {}",
+      );
+      expect(CodegenParserUtils.isMainFunctionWithArgs(name, paramList)).toBe(
+        true,
+      );
+    });
+
+    it("returns false for main with no parameters", () => {
+      const { name, paramList } = parseFunctionDeclaration("void main() {}");
+      expect(CodegenParserUtils.isMainFunctionWithArgs(name, paramList)).toBe(
+        false,
+      );
+    });
+
+    it("returns false for non-main function", () => {
+      const { name, paramList } = parseFunctionDeclaration(
+        "void foo(string args[]) {}",
+      );
+      expect(CodegenParserUtils.isMainFunctionWithArgs(name, paramList)).toBe(
+        false,
+      );
+    });
+
+    it("returns false for main with wrong parameter type", () => {
+      const { name, paramList } = parseFunctionDeclaration(
+        "void main(u32 count) {}",
+      );
+      expect(CodegenParserUtils.isMainFunctionWithArgs(name, paramList)).toBe(
+        false,
+      );
+    });
+
+    it("returns false for main with multiple parameters", () => {
+      const { name, paramList } = parseFunctionDeclaration(
+        "void main(string args[], u32 count) {}",
+      );
+      expect(CodegenParserUtils.isMainFunctionWithArgs(name, paramList)).toBe(
+        false,
+      );
+    });
+  });
+});

package/src/transpiler/types/IFileResult.ts

@@ -1,5 +1,4 @@
 import ITranspileError from "../../lib/types/ITranspileError";
-import ITranspileContribution from "./ITranspileContribution";
 
 /**
  * Result of transpiling a single file
@@ -25,9 +24,6 @@ interface IFileResult {
 
   /** Number of top-level declarations found */
   declarationCount: number;
-
-  /** Contributions from this file for accumulation in run() */
-  contribution?: ITranspileContribution;
 }
 
 export default IFileResult;