c-next 0.1.61 → 0.1.63

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

@@ -0,0 +1,177 @@
+/**
+ * SizeofResolver - Handles sizeof expression generation
+ *
+ * Extracted from CodeGenerator to reduce complexity.
+ * Uses CodeGenState for all state access.
+ *
+ * ADR-023: sizeof expression handling with safety checks:
+ * - E0601: sizeof on array parameter is error (returns pointer size)
+ * - E0602: Side effects in sizeof are error (MISRA C:2012 Rule 13.6)
+ */
+
+import * as Parser from "../../../logic/parser/grammar/CNextParser";
+import CodeGenState from "../CodeGenState";
+import ExpressionUnwrapper from "../utils/ExpressionUnwrapper";
+
+/**
+ * Callbacks for operations that require CodeGenerator context.
+ * These are the minimal dependencies that can't be replaced with CodeGenState.
+ */
+interface ISizeofCallbacks {
+  generateType: (ctx: Parser.TypeContext) => string;
+  generateExpression: (ctx: Parser.ExpressionContext) => string;
+  hasSideEffects: (ctx: Parser.ExpressionContext) => boolean;
+}
+
+/**
+ * Resolves sizeof expressions to C code.
+ */
+export default class SizeofResolver {
+  /**
+   * Generate sizeof expression.
+   * sizeof(type) -> sizeof(c_type)
+   * sizeof(variable) -> sizeof(variable)
+   */
+  static generate(
+    ctx: Parser.SizeofExpressionContext,
+    callbacks: ISizeofCallbacks,
+  ): string {
+    // Check if it's sizeof(type) or sizeof(expression)
+    // Note: Due to grammar ambiguity, sizeof(variable) may parse as sizeof(type)
+    // when the variable name matches userType (just an identifier)
+    if (ctx.type()) {
+      return this.sizeofType(ctx.type()!, callbacks);
+    }
+    return this.sizeofExpression(ctx.expression()!, callbacks);
+  }
+
+  /**
+   * Handle sizeof(type) - may actually be sizeof(variable) due to grammar ambiguity
+   */
+  private static sizeofType(
+    typeCtx: Parser.TypeContext,
+    callbacks: ISizeofCallbacks,
+  ): string {
+    // qualifiedType matches IDENTIFIER.IDENTIFIER, could be struct.member
+    if (typeCtx.qualifiedType()) {
+      const result = this.sizeofQualifiedType(typeCtx.qualifiedType()!);
+      if (result) return result;
+      // Fall through to generateType for actual type references (Scope.Type)
+    }
+
+    // userType is just IDENTIFIER, could be a variable reference
+    if (typeCtx.userType()) {
+      return this.sizeofUserType(typeCtx.getText());
+    }
+
+    // It's a primitive or other type - generate normally
+    return `sizeof(${callbacks.generateType(typeCtx)})`;
+  }
+
+  /**
+   * Handle sizeof(qualified.type) - may be struct.member access
+   * Returns null if this is actually a type reference (Scope.Type)
+   */
+  private static sizeofQualifiedType(
+    qualifiedCtx: Parser.QualifiedTypeContext,
+  ): string | null {
+    const identifiers = qualifiedCtx.IDENTIFIER();
+    const firstName = identifiers[0].getText();
+    const memberName = identifiers[1].getText();
+
+    // Check if first identifier is a local variable (struct instance)
+    if (CodeGenState.localVariables.has(firstName)) {
+      return `sizeof(${firstName}.${memberName})`;
+    }
+
+    // Check if first identifier is a parameter (struct parameter)
+    const paramInfo = CodeGenState.currentParameters.get(firstName);
+    if (paramInfo) {
+      const sep = paramInfo.isStruct ? "->" : ".";
+      return `sizeof(${firstName}${sep}${memberName})`;
+    }
+
+    // Check if first identifier is a global variable
+    // If not a scope or enum, it's likely a global struct variable
+    if (
+      !CodeGenState.isKnownScope(firstName) &&
+      !CodeGenState.isKnownEnum(firstName)
+    ) {
+      return `sizeof(${firstName}.${memberName})`;
+    }
+
+    // It's an actual type reference (Scope.Type), return null to fall through
+    return null;
+  }
+
+  /**
+   * Handle sizeof(identifier) - could be variable or type name
+   */
+  private static sizeofUserType(varName: string): string {
+    // Check if it's a known parameter
+    const paramInfo = CodeGenState.currentParameters.get(varName);
+    if (paramInfo) {
+      return this.sizeofParameter(varName, paramInfo);
+    }
+
+    // Check if it's a known local variable, struct type, or enum type
+    // For all these cases, generate sizeof(name) directly
+    // Unknown identifiers are also treated as variables for safety
+    return `sizeof(${varName})`;
+  }
+
+  /**
+   * Handle sizeof on a parameter - validates and generates appropriate code
+   */
+  private static sizeofParameter(
+    varName: string,
+    paramInfo: { isArray?: boolean; isCallback?: boolean; isStruct?: boolean },
+  ): string {
+    // E0601: Array parameters decay to pointers
+    if (paramInfo.isArray) {
+      this.throwArrayParamSizeofError(varName);
+    }
+    // For pass-by-reference parameters (non-array, non-callback, non-struct),
+    // use pointer dereference
+    if (!paramInfo.isCallback && !paramInfo.isStruct) {
+      return `sizeof(*${varName})`;
+    }
+    return `sizeof(${varName})`;
+  }
+
+  /**
+   * Throw E0601 error for sizeof on array parameter
+   */
+  private static throwArrayParamSizeofError(varName: string): never {
+    throw new Error(
+      `Error[E0601]: sizeof() on array parameter '${varName}' returns pointer size. ` +
+        `Use ${varName}.length for element count or sizeof(elementType) * ${varName}.length for bytes`,
+    );
+  }
+
+  /**
+   * Handle sizeof(expression) with validation
+   */
+  private static sizeofExpression(
+    expr: Parser.ExpressionContext,
+    callbacks: ISizeofCallbacks,
+  ): string {
+    // E0601: Check if expression is an array parameter
+    const varName = ExpressionUnwrapper.getSimpleIdentifier(expr);
+    if (varName) {
+      const paramInfo = CodeGenState.currentParameters.get(varName);
+      if (paramInfo?.isArray) {
+        this.throwArrayParamSizeofError(varName);
+      }
+    }
+
+    // E0602: Check for side effects
+    if (callbacks.hasSideEffects(expr)) {
+      throw new Error(
+        `Error[E0602]: sizeof() operand must not have side effects (MISRA C:2012 Rule 13.6)`,
+      );
+    }
+
+    return `sizeof(${callbacks.generateExpression(expr)})`;
+  }
+}

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

@@ -0,0 +1,336 @@
+/**
+ * Tests for EnumTypeResolver - enum type inference from expressions
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import EnumTypeResolver from "../EnumTypeResolver";
+import CodeGenState from "../../CodeGenState";
+import SymbolTable from "../../../../logic/symbols/SymbolTable";
+import ICodeGenSymbols from "../../../../types/ICodeGenSymbols";
+
+describe("EnumTypeResolver", () => {
+  const createMockSymbols = (
+    overrides: Partial<ICodeGenSymbols> = {},
+  ): ICodeGenSymbols =>
+    ({
+      knownScopes: new Set(),
+      knownEnums: new Set(),
+      knownBitmaps: new Set(),
+      knownStructs: new Set(),
+      knownRegisters: new Set(),
+      bitmapBitWidth: new Map(),
+      bitmapFields: new Map(),
+      bitmapBackingType: new Map(),
+      enumMembers: new Map(),
+      structFields: new Map(),
+      structFieldArrays: new Map(),
+      structFieldDimensions: new Map(),
+      functionReturnTypes: new Map(),
+      scopeMembers: new Map(),
+      scopeMemberVisibility: new Map(),
+      scopedRegisters: new Map(),
+      registerMemberAccess: new Map(),
+      registerMemberTypes: new Map(),
+      registerBaseAddresses: new Map(),
+      registerMemberOffsets: new Map(),
+      registerMemberCTypes: new Map(),
+      scopeVariableUsage: new Map(),
+      scopePrivateConstValues: new Map(),
+      getSingleFunctionForVariable: () => null,
+      hasPublicSymbols: () => false,
+      ...overrides,
+    }) as ICodeGenSymbols;
+
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
+  describe("resolve() - function call patterns", () => {
+    it("resolves function call returning enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["State"]),
+        functionReturnTypes: new Map([["getState", "State"]]),
+      });
+
+      const mockCtx = { getText: () => "getState()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("resolves this.method() returning enum type", () => {
+      CodeGenState.currentScope = "Motor";
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["State"]),
+        functionReturnTypes: new Map([["Motor_getState", "State"]]),
+      });
+
+      const mockCtx = { getText: () => "this.getState()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("resolves global.func() returning enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["State"]),
+        functionReturnTypes: new Map([["getGlobalState", "State"]]),
+      });
+
+      const mockCtx = { getText: () => "global.getGlobalState()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("resolves Scope.method() returning enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownScopes: new Set(["Motor"]),
+        knownEnums: new Set(["State"]),
+        functionReturnTypes: new Map([["Motor_getState", "State"]]),
+      });
+
+      const mockCtx = { getText: () => "Motor.getState()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("resolves global.Scope.method() returning enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownScopes: new Set(["Motor"]),
+        knownEnums: new Set(["State"]),
+        functionReturnTypes: new Map([["Motor_getState", "State"]]),
+      });
+
+      const mockCtx = { getText: () => "global.Motor.getState()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("returns null for function returning non-enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        functionReturnTypes: new Map([["getValue", "u32"]]),
+      });
+
+      const mockCtx = { getText: () => "getValue()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+
+    it("returns null for unknown function", () => {
+      CodeGenState.symbols = createMockSymbols();
+
+      const mockCtx = { getText: () => "unknownFunc()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+  });
+
+  describe("resolve() - simple identifier patterns", () => {
+    it("resolves enum variable by type registry lookup", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["State"]),
+      });
+      CodeGenState.typeRegistry.set("currentState", {
+        baseType: "State",
+        bitWidth: 0,
+        isArray: false,
+        isConst: false,
+        isEnum: true,
+        enumTypeName: "State",
+      });
+
+      const mockCtx = { getText: () => "currentState" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("returns null for non-enum variable", () => {
+      CodeGenState.typeRegistry.set("count", {
+        baseType: "u32",
+        bitWidth: 32,
+        isArray: false,
+        isConst: false,
+      });
+
+      const mockCtx = { getText: () => "count" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+  });
+
+  describe("resolve() - member access patterns", () => {
+    it("resolves simple enum member access: State.IDLE", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["State"]),
+      });
+
+      const mockCtx = { getText: () => "State.IDLE" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("resolves scoped enum: Motor.State.IDLE -> Motor_State", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Motor_State"]),
+      });
+
+      const mockCtx = { getText: () => "Motor.State.IDLE" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("Motor_State");
+    });
+
+    it("resolves this.Enum.MEMBER inside scope", () => {
+      CodeGenState.currentScope = "Motor";
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Motor_State"]),
+      });
+
+      const mockCtx = { getText: () => "this.State.IDLE" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("Motor_State");
+    });
+
+    it("resolves global.Enum.MEMBER pattern", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["ECategory"]),
+      });
+
+      const mockCtx = { getText: () => "global.ECategory.CAT_A" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("ECategory");
+    });
+
+    it("resolves this.variable pattern for enum-typed scope member", () => {
+      CodeGenState.currentScope = "Motor";
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Motor_State"]),
+      });
+      CodeGenState.typeRegistry.set("Motor_current", {
+        baseType: "Motor_State",
+        bitWidth: 0,
+        isArray: false,
+        isConst: false,
+        isEnum: true,
+        enumTypeName: "Motor_State",
+      });
+
+      const mockCtx = { getText: () => "this.current" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("Motor_State");
+    });
+  });
+
+  describe("resolve() - TypeResolver fallback for struct member chains", () => {
+    /**
+     * Helper to build a mock ExpressionContext that contains a full postfix
+     * expression tree: global.input.assignedValue
+     */
+    const buildStructChainCtx = (
+      primaryToken: "GLOBAL" | "THIS" | "IDENTIFIER",
+      primaryText: string,
+      suffixes: string[],
+    ) => {
+      const primary = {
+        IDENTIFIER: () =>
+          primaryToken === "IDENTIFIER" ? { getText: () => primaryText } : null,
+        GLOBAL: () =>
+          primaryToken === "GLOBAL" ? { getText: () => "global" } : null,
+        THIS: () =>
+          primaryToken === "THIS" ? { getText: () => "this" } : null,
+        literal: () => null,
+        expression: () => null,
+        castExpression: () => null,
+      };
+      const children = [
+        { getText: () => primaryText },
+        ...suffixes.map((s) => ({ getText: () => s })),
+      ];
+      const postfix = { primaryExpression: () => primary, children };
+
+      // Build the full expression tree wrapping the postfix
+      const unary = {
+        postfixExpression: () => postfix,
+        unaryExpression: () => null,
+      };
+      const mult = { unaryExpression: () => [unary] };
+      const add = { multiplicativeExpression: () => [mult] };
+      const shift = { additiveExpression: () => [add] };
+      const bitAnd = { shiftExpression: () => [shift] };
+      const bitXor = { bitwiseAndExpression: () => [bitAnd] };
+      const bitOr = { bitwiseXorExpression: () => [bitXor] };
+      const rel = { bitwiseOrExpression: () => [bitOr] };
+      const eq = { relationalExpression: () => [rel] };
+      const and = { equalityExpression: () => [eq] };
+      const or = { andExpression: () => [and] };
+      const ternary = { orExpression: () => [or] };
+
+      return {
+        getText: () => primaryText + suffixes.join(""),
+        ternaryExpression: () => ternary,
+      } as never;
+    };
+
+    it("resolves global.struct.enumField via TypeResolver fallback", () => {
+      const symbolTable = new SymbolTable();
+      symbolTable.addStructField("TInput", "assignedValue", "EValueId");
+      CodeGenState.symbolTable = symbolTable;
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["EValueId"]),
+      });
+      CodeGenState.typeRegistry.set("input", {
+        baseType: "TInput",
+        bitWidth: 0,
+        isArray: false,
+        isConst: false,
+      });
+
+      const ctx = buildStructChainCtx("GLOBAL", "global", [
+        ".input",
+        ".assignedValue",
+      ]);
+      expect(EnumTypeResolver.resolve(ctx)).toBe("EValueId");
+    });
+
+    it("returns null when struct field is not an enum type", () => {
+      const symbolTable = new SymbolTable();
+      symbolTable.addStructField("TInput", "count", "u32");
+      CodeGenState.symbolTable = symbolTable;
+      CodeGenState.symbols = createMockSymbols();
+      CodeGenState.typeRegistry.set("input", {
+        baseType: "TInput",
+        bitWidth: 0,
+        isArray: false,
+        isConst: false,
+      });
+
+      const ctx = buildStructChainCtx("GLOBAL", "global", [".input", ".count"]);
+      expect(EnumTypeResolver.resolve(ctx)).toBeNull();
+    });
+
+    it("returns null for RelationalExpressionContext (no ternaryExpression)", () => {
+      CodeGenState.symbols = createMockSymbols();
+      // RelationalExpressionContext doesn't have ternaryExpression
+      const ctx = { getText: () => "something.weird" } as never;
+      expect(EnumTypeResolver.resolve(ctx)).toBeNull();
+    });
+  });
+
+  describe("resolve() - edge cases", () => {
+    it("returns null for this.Enum.MEMBER when not in a scope", () => {
+      CodeGenState.currentScope = null;
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Motor_State"]),
+      });
+
+      const mockCtx = { getText: () => "this.State.IDLE" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+
+    it("returns null for this.variable when not in a scope", () => {
+      CodeGenState.currentScope = null;
+
+      const mockCtx = { getText: () => "this.current" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+
+    it("returns null for unknown enum in scoped pattern", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(), // No enums
+      });
+
+      const mockCtx = { getText: () => "Motor.State.IDLE" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+
+    it("returns null for single identifier that is not in type registry", () => {
+      CodeGenState.symbols = createMockSymbols();
+
+      const mockCtx = { getText: () => "unknownVar" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+  });
+});