c-next 0.1.62 → 0.1.63

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

@@ -0,0 +1,229 @@
+/**
+ * EnumTypeResolver - Handles enum type inference from expressions
+ *
+ * Extracted from CodeGenerator to reduce complexity.
+ * Uses CodeGenState for all state access.
+ *
+ * ADR-017: Extract enum type from expressions for type-safe comparisons.
+ * Handles patterns:
+ * - Variable of enum type: `currentState` -> 'State'
+ * - Enum member access: `State.IDLE` -> 'State'
+ * - Scoped enum member: `Motor.State.IDLE` -> 'Motor_State'
+ * - ADR-016: this.State.IDLE -> 'CurrentScope_State'
+ * - ADR-016: this.variable -> enum type if variable is of enum type
+ * - Function calls returning enum types
+ */
+
+import * as Parser from "../../../logic/parser/grammar/CNextParser";
+import CodeGenState from "../CodeGenState";
+import TypeResolver from "../TypeResolver";
+import ExpressionUnwrapper from "../utils/ExpressionUnwrapper";
+
+/**
+ * Resolves enum types from expressions.
+ * All methods are static - uses CodeGenState for state access.
+ */
+export default class EnumTypeResolver {
+  /**
+   * Extract enum type from an expression.
+   * Returns the enum type name if the expression is an enum value, null otherwise.
+   */
+  static resolve(
+    ctx: Parser.ExpressionContext | Parser.RelationalExpressionContext,
+  ): string | null {
+    const text = ctx.getText();
+
+    // Check if it's a function call returning an enum
+    const enumReturnType = this.getFunctionCallEnumType(text);
+    if (enumReturnType) {
+      return enumReturnType;
+    }
+
+    // Check if it's a simple identifier that's an enum variable
+    if (/^[a-zA-Z_]\w*$/.exec(text)) {
+      const typeInfo = CodeGenState.typeRegistry.get(text);
+      if (typeInfo?.isEnum && typeInfo.enumTypeName) {
+        return typeInfo.enumTypeName;
+      }
+    }
+
+    // Check member access patterns: EnumType.MEMBER, Scope.EnumType.MEMBER, etc.
+    const memberResult = this.getEnumTypeFromMemberAccess(text.split("."));
+    if (memberResult) {
+      return memberResult;
+    }
+
+    // Fallback: use TypeResolver to resolve the full expression type through
+    // struct member chains (e.g. global.config.inputs[0].assignedValue -> EValueId)
+    return this.resolveViaTypeResolver(ctx);
+  }
+
+  /**
+   * Fallback resolution via TypeResolver for complex expressions.
+   * Handles struct member chains like global.struct.field that resolve to enum types.
+   */
+  private static resolveViaTypeResolver(
+    ctx: Parser.ExpressionContext | Parser.RelationalExpressionContext,
+  ): string | null {
+    // ExpressionContext has getPostfixExpression, RelationalExpressionContext does not
+    if (!("ternaryExpression" in ctx)) {
+      return null;
+    }
+    const postfix = ExpressionUnwrapper.getPostfixExpression(ctx);
+    if (!postfix) {
+      return null;
+    }
+    const resolvedType = TypeResolver.getPostfixExpressionType(postfix);
+    if (resolvedType && CodeGenState.isKnownEnum(resolvedType)) {
+      return resolvedType;
+    }
+    return null;
+  }
+
+  /**
+   * Check if parts represent an enum member access and return the enum type.
+   */
+  private static getEnumTypeFromMemberAccess(parts: string[]): string | null {
+    if (parts.length < 2) {
+      return null;
+    }
+
+    // ADR-016: Check this.State.IDLE pattern
+    const thisEnumType = this.getEnumTypeFromThisEnum(parts);
+    if (thisEnumType) return thisEnumType;
+
+    // Issue #478: Check global.Enum.Member pattern
+    const globalEnumType = this.getEnumTypeFromGlobalEnum(parts);
+    if (globalEnumType) return globalEnumType;
+
+    // ADR-016: Check this.variable pattern
+    const thisVarType = this.getEnumTypeFromThisVariable(parts);
+    if (thisVarType) return thisVarType;
+
+    // Check simple enum: State.IDLE
+    const possibleEnum = parts[0];
+    if (CodeGenState.isKnownEnum(possibleEnum)) {
+      return possibleEnum;
+    }
+
+    // Check scoped enum: Motor.State.IDLE -> Motor_State
+    return this.getEnumTypeFromScopedEnum(parts);
+  }
+
+  /**
+   * ADR-016: Check this.State.IDLE pattern (this.Enum.Member inside scope)
+   */
+  private static getEnumTypeFromThisEnum(parts: string[]): string | null {
+    if (parts[0] !== "this" || !CodeGenState.currentScope || parts.length < 3) {
+      return null;
+    }
+    const enumName = parts[1];
+    const scopedEnumName = `${CodeGenState.currentScope}_${enumName}`;
+    return CodeGenState.isKnownEnum(scopedEnumName) ? scopedEnumName : null;
+  }
+
+  /**
+   * Issue #478: Check global.Enum.Member pattern (global.ECategory.CAT_A)
+   */
+  private static getEnumTypeFromGlobalEnum(parts: string[]): string | null {
+    if (parts[0] !== "global" || parts.length < 3) {
+      return null;
+    }
+    const enumName = parts[1];
+    return CodeGenState.isKnownEnum(enumName) ? enumName : null;
+  }
+
+  /**
+   * ADR-016: Check this.variable pattern (this.varName where varName is enum type)
+   */
+  private static getEnumTypeFromThisVariable(parts: string[]): string | null {
+    if (
+      parts[0] !== "this" ||
+      !CodeGenState.currentScope ||
+      parts.length !== 2
+    ) {
+      return null;
+    }
+    const varName = parts[1];
+    const scopedVarName = `${CodeGenState.currentScope}_${varName}`;
+    const typeInfo = CodeGenState.typeRegistry.get(scopedVarName);
+    if (typeInfo?.isEnum && typeInfo.enumTypeName) {
+      return typeInfo.enumTypeName;
+    }
+    return null;
+  }
+
+  /**
+   * Check scoped enum: Motor.State.IDLE -> Motor_State
+   */
+  private static getEnumTypeFromScopedEnum(parts: string[]): string | null {
+    if (parts.length < 3) {
+      return null;
+    }
+    const scopeName = parts[0];
+    const enumName = parts[1];
+    const scopedEnumName = `${scopeName}_${enumName}`;
+    return CodeGenState.isKnownEnum(scopedEnumName) ? scopedEnumName : null;
+  }
+
+  /**
+   * Check if an expression is a function call returning an enum type.
+   * Handles patterns:
+   * - func() or func(args) - global function
+   * - Scope.method() or Scope.method(args) - scope method from outside
+   * - this.method() or this.method(args) - scope method from inside
+   * - global.func() or global.func(args) - global function from inside scope
+   * - global.Scope.method() or global.Scope.method(args) - scope method from inside another scope
+   */
+  private static getFunctionCallEnumType(text: string): string | null {
+    // Check if this looks like a function call (contains parentheses)
+    const parenIndex = text.indexOf("(");
+    if (parenIndex === -1) {
+      return null;
+    }
+
+    // Extract the function reference (everything before the opening paren)
+    const funcRef = text.substring(0, parenIndex);
+    const parts = funcRef.split(".");
+
+    let fullFuncName: string | null = null;
+
+    if (parts.length === 1) {
+      // Simple function call: func()
+      fullFuncName = parts[0];
+    } else if (parts.length === 2) {
+      if (parts[0] === "this" && CodeGenState.currentScope) {
+        // this.method() -> Scope_method
+        fullFuncName = `${CodeGenState.currentScope}_${parts[1]}`;
+      } else if (parts[0] === "global") {
+        // global.func() -> func
+        fullFuncName = parts[1];
+      } else if (CodeGenState.isKnownScope(parts[0])) {
+        // Scope.method() -> Scope_method
+        fullFuncName = `${parts[0]}_${parts[1]}`;
+      }
+    } else if (parts.length === 3) {
+      if (parts[0] === "global" && CodeGenState.isKnownScope(parts[1])) {
+        // global.Scope.method() -> Scope_method
+        fullFuncName = `${parts[1]}_${parts[2]}`;
+      }
+    }
+
+    if (!fullFuncName) {
+      return null;
+    }
+
+    // Look up the function's return type
+    const returnType = CodeGenState.getFunctionReturnType(fullFuncName);
+    if (!returnType) {
+      return null;
+    }
+
+    // Check if the return type is an enum
+    if (CodeGenState.isKnownEnum(returnType)) {
+      return returnType;
+    }
+
+    return null;
+  }
+}

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

@@ -0,0 +1,60 @@
+/**
+ * ScopeResolver - Handles scope visibility and access validation
+ *
+ * Extracted from CodeGenerator to reduce complexity.
+ * Uses CodeGenState for all state access.
+ *
+ * ADR-016: Validates cross-scope member access visibility rules.
+ * Issue #165: Enforces that:
+ * - Cannot reference own scope by name (must use this. prefix)
+ * - Cannot access private members from outside the scope
+ * - Exception: global.Scope.member is allowed for explicit qualification
+ */
+
+import CodeGenState from "../CodeGenState";
+
+/**
+ * Resolves scope visibility and validates cross-scope access.
+ * All methods are static - uses CodeGenState for state access.
+ */
+export default class ScopeResolver {
+  /**
+   * Validate cross-scope visibility for member access.
+   * Throws an error if the access violates visibility rules.
+   *
+   * @param scopeName - The scope being accessed
+   * @param memberName - The member being accessed
+   * @param isGlobalAccess - Whether this is a global.Scope.member access
+   */
+  static validateCrossScopeVisibility(
+    scopeName: string,
+    memberName: string,
+    isGlobalAccess: boolean = false,
+  ): void {
+    // Error if referencing own scope by name (must use this. prefix)
+    // Exception: global.Scope.member is allowed for explicit qualification
+    if (!isGlobalAccess && CodeGenState.currentScope === scopeName) {
+      throw new Error(
+        `Error: Cannot reference own scope '${scopeName}' by name. ` +
+          `Use 'this.${memberName}' instead of '${scopeName}.${memberName}'`,
+      );
+    }
+
+    // Check private member access (skip for own scope - we can access our own privates)
+    const isOwnScope = CodeGenState.currentScope === scopeName;
+    if (!isOwnScope) {
+      const visibility = CodeGenState.symbols?.scopeMemberVisibility
+        .get(scopeName)
+        ?.get(memberName);
+      if (visibility === "private") {
+        const context = CodeGenState.currentScope
+          ? `from scope '${CodeGenState.currentScope}'`
+          : "from outside the scope";
+        throw new Error(
+          `Cannot access private member '${memberName}' of scope '${scopeName}' ${context}. ` +
+            `Only public members are accessible outside their scope.`,
+        );
+      }
+    }
+  }
+}

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)})`;
+  }
+}