c-next 0.1.42 → 0.1.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.42",
+  "version": "0.1.43",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {

package/src/codegen/CodeGenerator.ts

@@ -3698,6 +3698,12 @@ export default class CodeGenerator implements IOrchestrator {
     // Get the text representation to analyze
     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 = this.context.typeRegistry.get(text);
@@ -3765,6 +3771,61 @@ export default class CodeGenerator implements IOrchestrator {
     return 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
+   */
+  private _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" && this.context.currentScope) {
+        // this.method() -> Scope_method
+        fullFuncName = `${this.context.currentScope}_${parts[1]}`;
+      } else if (parts[0] === "global") {
+        // global.func() -> func
+        fullFuncName = parts[1];
+      } else if (this.symbols!.knownScopes.has(parts[0])) {
+        // Scope.method() -> Scope_method
+        fullFuncName = `${parts[0]}_${parts[1]}`;
+      }
+    }
+
+    if (!fullFuncName) {
+      return null;
+    }
+
+    // Look up the function's return type
+    const returnType = this.symbols!.functionReturnTypes.get(fullFuncName);
+    if (!returnType) {
+      return null;
+    }
+
+    // Check if the return type is an enum
+    if (this.symbols!.knownEnums.has(returnType)) {
+      return returnType;
+    }
+
+    return null;
+  }
+
   /**
    * ADR-017: Check if an expression represents an integer literal or numeric type.
    * Used to detect comparisons between enums and integers.

package/src/codegen/generators/ISymbolInfo.ts

@@ -108,6 +108,15 @@ interface ISymbolInfo {
    */
   readonly scopePrivateConstValues: ReadonlyMap<string, string>;
 
+  // === Function Return Types ===
+
+  /**
+   * Function return types: "functionName" -> return type string.
+   * Used to determine enum types for function call expressions.
+   * Keys are full function names (e.g., "Motor_getMode" for scope methods, "getState" for globals).
+   */
+  readonly functionReturnTypes: ReadonlyMap<string, string>;
+
   /**
    * Check if a scope variable is used in only one function.
    * Returns the function name if single-function, null otherwise.

package/src/symbol_resolution/cnext/adapters/TSymbolInfoAdapter.ts

@@ -13,6 +13,7 @@ import ESymbolKind from "../../../types/ESymbolKind";
 import TSymbol from "../../types/TSymbol";
 import IBitmapSymbol from "../../types/IBitmapSymbol";
 import IEnumSymbol from "../../types/IEnumSymbol";
+import IFunctionSymbol from "../../types/IFunctionSymbol";
 import IStructSymbol from "../../types/IStructSymbol";
 import IRegisterSymbol from "../../types/IRegisterSymbol";
 import IScopeSymbol from "../../types/IScopeSymbol";
@@ -86,6 +87,9 @@ class TSymbolInfoAdapter {
     // === Issue #282: Private const values for inlining ===
     const scopePrivateConstValues = new Map<string, string>();
 
+    // === Function Return Types ===
+    const functionReturnTypes = new Map<string, string>();
+
     // Process each symbol
     for (const symbol of symbols) {
       switch (symbol.kind) {
@@ -141,8 +145,9 @@ class TSymbolInfoAdapter {
           TSymbolInfoAdapter.processVariable(symbol, scopePrivateConstValues);
           break;
 
-        // Functions don't add to ISymbolInfo directly
+        // Track function return types for enum validation
         case ESymbolKind.Function:
+          TSymbolInfoAdapter.processFunction(symbol, functionReturnTypes);
           break;
       }
     }
@@ -185,6 +190,9 @@ class TSymbolInfoAdapter {
       // Issue #282: Private const values for inlining
       scopePrivateConstValues,
 
+      // Function return types
+      functionReturnTypes,
+
       // Methods
       getSingleFunctionForVariable: (scopeName: string, varName: string) =>
         TSymbolInfoAdapter.getSingleFunctionForVariable(
@@ -346,6 +354,15 @@ class TSymbolInfoAdapter {
     }
   }
 
+  private static processFunction(
+    func: IFunctionSymbol,
+    functionReturnTypes: Map<string, string>,
+  ): void {
+    // Track function return types for enum validation in assignments
+    // This enables recognizing that Motor.getMode() returns Motor_EMode
+    functionReturnTypes.set(func.name, func.returnType);
+  }
+
   private static cnextTypeToCType(typeName: string): string {
     return CNEXT_TO_C_TYPE[typeName] || typeName;
   }
@@ -390,13 +407,19 @@ class TSymbolInfoAdapter {
     // Create mutable copies of enum-related data
     const mergedKnownEnums = new Set(base.knownEnums);
     const mergedEnumMembers = new Map<string, Map<string, number>>();
+    const mergedFunctionReturnTypes = new Map<string, string>();
 
     // Copy base enum members
     for (const [enumName, members] of base.enumMembers) {
       mergedEnumMembers.set(enumName, new Map(members));
     }
 
-    // Merge in external enum info
+    // Copy base function return types
+    for (const [funcName, returnType] of base.functionReturnTypes) {
+      mergedFunctionReturnTypes.set(funcName, returnType);
+    }
+
+    // Merge in external enum info and function return types
     for (const external of externalEnumSources) {
       for (const enumName of external.knownEnums) {
         mergedKnownEnums.add(enumName);
@@ -407,6 +430,12 @@ class TSymbolInfoAdapter {
           mergedEnumMembers.set(enumName, new Map(members));
         }
       }
+      // Merge function return types from external sources
+      for (const [funcName, returnType] of external.functionReturnTypes) {
+        if (!mergedFunctionReturnTypes.has(funcName)) {
+          mergedFunctionReturnTypes.set(funcName, returnType);
+        }
+      }
     }
 
     // Return new ISymbolInfo with merged enum data
@@ -448,6 +477,9 @@ class TSymbolInfoAdapter {
       // Private const values
       scopePrivateConstValues: base.scopePrivateConstValues,
 
+      // Function return types - merged
+      functionReturnTypes: mergedFunctionReturnTypes,
+
       // Methods - delegate to base's implementation
       getSingleFunctionForVariable: base.getSingleFunctionForVariable,
       hasPublicSymbols: base.hasPublicSymbols,