c-next 0.1.61 → 0.1.63

package/src/transpiler/output/codegen/helpers/__tests__/SymbolLookupHelper.test.ts

@@ -323,4 +323,205 @@ describe("SymbolLookupHelper", () => {
       );
     });
   });
+
+  describe("isCNextFunctionCombined", () => {
+    it("returns true when in knownFunctions set", () => {
+      const knownFunctions = new Set(["myFunc"]);
+      expect(
+        SymbolLookupHelper.isCNextFunctionCombined(
+          knownFunctions,
+          null,
+          "myFunc",
+        ),
+      ).toBe(true);
+    });
+
+    it("returns true when in symbol table as C-Next function", () => {
+      const mockTable = {
+        getOverloads: () => [
+          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.CNext },
+        ],
+      };
+      expect(
+        SymbolLookupHelper.isCNextFunctionCombined(
+          new Set(),
+          mockTable,
+          "myFunc",
+        ),
+      ).toBe(true);
+    });
+
+    it("returns false when not in knownFunctions and not in symbol table", () => {
+      const mockTable = {
+        getOverloads: () => [],
+      };
+      expect(
+        SymbolLookupHelper.isCNextFunctionCombined(
+          new Set(),
+          mockTable,
+          "myFunc",
+        ),
+      ).toBe(false);
+    });
+
+    it("returns false when knownFunctions is undefined and not in symbol table", () => {
+      expect(
+        SymbolLookupHelper.isCNextFunctionCombined(undefined, null, "myFunc"),
+      ).toBe(false);
+    });
+
+    it("prioritizes knownFunctions over symbol table", () => {
+      const knownFunctions = new Set(["myFunc"]);
+      const mockTable = {
+        getOverloads: () => [
+          { kind: ESymbolKind.Function, sourceLanguage: ESourceLanguage.C },
+        ],
+      };
+      expect(
+        SymbolLookupHelper.isCNextFunctionCombined(
+          knownFunctions,
+          mockTable,
+          "myFunc",
+        ),
+      ).toBe(true);
+    });
+  });
+
+  describe("isKnownScope", () => {
+    it("returns true when in knownScopes set", () => {
+      const knownScopes = new Set(["MyScope"]);
+      expect(
+        SymbolLookupHelper.isKnownScope(knownScopes, null, "MyScope"),
+      ).toBe(true);
+    });
+
+    it("returns true when in symbol table as namespace", () => {
+      const mockTable = {
+        getOverloads: () => [
+          {
+            kind: ESymbolKind.Namespace,
+            sourceLanguage: ESourceLanguage.CNext,
+          },
+        ],
+      };
+      expect(
+        SymbolLookupHelper.isKnownScope(new Set(), mockTable, "MyScope"),
+      ).toBe(true);
+    });
+
+    it("returns false when not in knownScopes and not in symbol table", () => {
+      const mockTable = {
+        getOverloads: () => [],
+      };
+      expect(
+        SymbolLookupHelper.isKnownScope(new Set(), mockTable, "MyScope"),
+      ).toBe(false);
+    });
+
+    it("returns false when knownScopes is undefined and not in symbol table", () => {
+      expect(SymbolLookupHelper.isKnownScope(undefined, null, "MyScope")).toBe(
+        false,
+      );
+    });
+
+    it("prioritizes knownScopes over symbol table", () => {
+      const knownScopes = new Set(["MyScope"]);
+      const mockTable = {
+        getOverloads: () => [],
+      };
+      expect(
+        SymbolLookupHelper.isKnownScope(knownScopes, mockTable, "MyScope"),
+      ).toBe(true);
+    });
+  });
+
+  describe("isKnownStruct", () => {
+    it("returns true when in knownStructs set", () => {
+      const knownStructs = new Set(["MyStruct"]);
+      expect(
+        SymbolLookupHelper.isKnownStruct(
+          knownStructs,
+          undefined,
+          null,
+          "MyStruct",
+        ),
+      ).toBe(true);
+    });
+
+    it("returns true when in knownBitmaps set", () => {
+      const knownBitmaps = new Set(["MyBitmap"]);
+      expect(
+        SymbolLookupHelper.isKnownStruct(
+          new Set(),
+          knownBitmaps,
+          null,
+          "MyBitmap",
+        ),
+      ).toBe(true);
+    });
+
+    it("returns true when in symbol table via getStructFields", () => {
+      const mockTable = {
+        getOverloads: () => [],
+        getStructFields: (name: string) =>
+          name === "CStruct" ? new Map([["field", "int"]]) : undefined,
+      };
+      expect(
+        SymbolLookupHelper.isKnownStruct(
+          new Set(),
+          new Set(),
+          mockTable,
+          "CStruct",
+        ),
+      ).toBe(true);
+    });
+
+    it("returns false when not found anywhere", () => {
+      const mockTable = {
+        getOverloads: () => [],
+        getStructFields: () => undefined,
+      };
+      expect(
+        SymbolLookupHelper.isKnownStruct(
+          new Set(),
+          new Set(),
+          mockTable,
+          "Unknown",
+        ),
+      ).toBe(false);
+    });
+
+    it("returns false when all sources are undefined/null", () => {
+      expect(
+        SymbolLookupHelper.isKnownStruct(undefined, undefined, null, "Unknown"),
+      ).toBe(false);
+    });
+
+    it("checks knownStructs before knownBitmaps", () => {
+      const knownStructs = new Set(["MyType"]);
+      const knownBitmaps = new Set<string>();
+      expect(
+        SymbolLookupHelper.isKnownStruct(
+          knownStructs,
+          knownBitmaps,
+          null,
+          "MyType",
+        ),
+      ).toBe(true);
+    });
+
+    it("handles symbol table without getStructFields method", () => {
+      const mockTable = {
+        getOverloads: () => [],
+      };
+      expect(
+        SymbolLookupHelper.isKnownStruct(
+          new Set(),
+          new Set(),
+          mockTable,
+          "Unknown",
+        ),
+      ).toBe(false);
+    });
+  });
 });

package/src/transpiler/output/codegen/helpers/__tests__/TypeGenerationHelper.test.ts

@@ -182,6 +182,16 @@ describe("TypeGenerationHelper", () => {
       expect(result).toBe("uint32_t");
     });
 
+    it("returns unknown primitive type unchanged", () => {
+      // When primitive type is not in TYPE_MAP, return as-is
+      const result = TypeGenerationHelper.generateArrayBaseType(
+        "unknownType",
+        null,
+        false,
+      );
+      expect(result).toBe("unknownType");
+    });
+
     it("returns user type unchanged", () => {
       const result = TypeGenerationHelper.generateArrayBaseType(
         null,
@@ -321,12 +331,52 @@ describe("TypeGenerationHelper", () => {
       expect(result).toBe("uint8_t");
     });
 
+    it("generates array type with primitive via generate()", () => {
+      // Array type in type position: u8[10] as the type
+      const ctx = getTypeContext("u8[10] arr;");
+      expect(ctx).not.toBeNull();
+      expect(ctx!.arrayType()).not.toBeNull();
+      const result = TypeGenerationHelper.generate(ctx!, defaultDeps);
+      expect(result).toBe("uint8_t");
+    });
+
+    it("generates array type with user type via generate()", () => {
+      // Array of user-defined type: MyStruct[5] as the type
+      const ctx = getTypeContext("MyStruct[5] arr;");
+      expect(ctx).not.toBeNull();
+      expect(ctx!.arrayType()).not.toBeNull();
+      const result = TypeGenerationHelper.generate(ctx!, defaultDeps);
+      expect(result).toBe("MyStruct");
+    });
+
+    it("generates array type with user type needing struct keyword", () => {
+      // Array of C struct type that needs 'struct' prefix
+      const ctx = getTypeContext("CStruct[3] arr;");
+      expect(ctx).not.toBeNull();
+      expect(ctx!.arrayType()).not.toBeNull();
+      const result = TypeGenerationHelper.generate(ctx!, {
+        ...defaultDeps,
+        checkNeedsStructKeyword: (name) => name === "CStruct",
+      });
+      expect(result).toBe("struct CStruct");
+    });
+
     it("generates void return type", () => {
       const ctx = getFunctionReturnType("void test() { }");
       expect(ctx).not.toBeNull();
       const result = TypeGenerationHelper.generate(ctx!, defaultDeps);
       expect(result).toBe("void");
     });
+
+    it("passes through C++ template types unchanged (fallback)", () => {
+      // C++ template types like FlexCAN_T4<CAN1> hit the fallback path
+      // and are passed through unchanged for C++ output
+      const ctx = getTypeContext("FlexCAN_T4<CAN1> bus;");
+      expect(ctx).not.toBeNull();
+      expect(ctx!.templateType()).not.toBeNull();
+      const result = TypeGenerationHelper.generate(ctx!, defaultDeps);
+      expect(result).toBe("FlexCAN_T4<CAN1>");
+    });
   });
 
   describe("getRequiredInclude", () => {

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