c-next 0.2.5 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

package/src/transpiler/logic/analysis/FunctionCallAnalyzer.ts

@@ -572,6 +572,9 @@ class FunctionCallAnalyzer {
     );
   }
 
+  /** Current scope name during callback assignment scanning */
+  private scanCurrentScope: string | null = null;
+
   /**
    * Detect functions assigned to C function pointer typedefs.
    * When `PointCallback cb <- my_handler;` is found and PointCallback
@@ -582,13 +585,61 @@ class FunctionCallAnalyzer {
   ): void {
     for (const decl of tree.declaration()) {
       const funcDecl = decl.functionDeclaration();
-      if (!funcDecl) continue;
+      if (funcDecl) {
+        this.scanStandaloneFunctionForCallbacks(funcDecl);
+        continue;
+      }
+
+      const scopeDecl = decl.scopeDeclaration();
+      if (scopeDecl) {
+        this.scanScopeForCallbacks(scopeDecl);
+      }
+    }
+  }
+
+  /**
+   * Scan a standalone function declaration for callback assignments.
+   */
+  private scanStandaloneFunctionForCallbacks(
+    funcDecl: Parser.FunctionDeclarationContext,
+  ): void {
+    const block = funcDecl.block();
+    if (!block) return;
+
+    this.scanCurrentScope = null;
+    this.scanBlockForCallbackAssignments(block);
+  }
 
-      const block = funcDecl.block();
-      if (!block) continue;
+  /**
+   * Scan all member functions in a scope for callback assignments (Issue #895).
+   */
+  private scanScopeForCallbacks(
+    scopeDecl: Parser.ScopeDeclarationContext,
+  ): void {
+    const scopeName = scopeDecl.IDENTIFIER().getText();
 
-      this.scanBlockForCallbackAssignments(block);
+    for (const member of scopeDecl.scopeMember()) {
+      this.scanScopeMemberForCallbacks(member, scopeName);
     }
+
+    this.scanCurrentScope = null;
+  }
+
+  /**
+   * Scan a single scope member for callback assignments.
+   */
+  private scanScopeMemberForCallbacks(
+    member: Parser.ScopeMemberContext,
+    scopeName: string,
+  ): void {
+    const memberFunc = member.functionDeclaration();
+    if (!memberFunc) return;
+
+    const block = memberFunc.block();
+    if (!block) return;
+
+    this.scanCurrentScope = scopeName;
+    this.scanBlockForCallbackAssignments(block);
   }
 
   /**
@@ -702,17 +753,41 @@ class FunctionCallAnalyzer {
 
   /**
    * Extract a function reference from an expression context.
-   * Matches bare identifiers (e.g., "my_handler") and qualified scope
-   * names (e.g., "MyScope.handler").
+   * Matches:
+   *   - Bare identifiers: "my_handler"
+   *   - Qualified scope names: "MyScope.handler"
+   *   - Self-scope reference: "this.handler" (resolved using scanCurrentScope)
+   *   - Global scope reference: "global.ScopeName.handler"
    * Returns null if the expression is not a function reference.
    */
   private extractFunctionReference(
     expr: Parser.ExpressionContext,
   ): string | null {
     const text = expr.getText();
-    if (/^\w+(\.\w+)?$/.test(text)) {
+
+    // Pattern 1: this.member -> CurrentScope.member (Issue #895)
+    const thisPattern = /^this\.(\w+)$/;
+    const thisMatch = thisPattern.exec(text);
+    if (thisMatch) {
+      if (!this.scanCurrentScope) {
+        return null; // this.member outside scope context
+      }
+      return this.scanCurrentScope + "." + thisMatch[1];
+    }
+
+    // Pattern 2: global.Scope.member -> Scope.member (Issue #895)
+    const globalPattern = /^global\.(\w+)\.(\w+)$/;
+    const globalMatch = globalPattern.exec(text);
+    if (globalMatch) {
+      return globalMatch[1] + "." + globalMatch[2];
+    }
+
+    // Pattern 3: Bare identifier or simple Scope.member
+    const simplePattern = /^\w+(\.\w+)?$/;
+    if (simplePattern.test(text)) {
       return text;
     }
+
     return null;
   }
 

package/src/transpiler/logic/analysis/__tests__/FunctionCallAnalyzer.test.ts

@@ -25,6 +25,38 @@ function parse(source: string) {
   return parser.program();
 }
 
+/**
+ * Helper to register widget callback symbols for Issue #895 tests.
+ * Adds widget_set_flush_cb function and flush_cb_t typedef to symbol table.
+ */
+function addWidgetCallbackSymbols(symbolTable: SymbolTable): void {
+  // Register the C function that takes a callback parameter
+  symbolTable.addCSymbol({
+    name: "widget_set_flush_cb",
+    kind: "function",
+    sourceLanguage: ESourceLanguage.C,
+    sourceFile: "widget.h",
+    sourceLine: 1,
+    isExported: true,
+    type: "void",
+    parameters: [
+      { name: "w", type: "widget_t*", isConst: false, isArray: false },
+      { name: "cb", type: "flush_cb_t", isConst: false, isArray: false },
+    ],
+  });
+
+  // Register the callback typedef
+  symbolTable.addCSymbol({
+    name: "flush_cb_t",
+    kind: "type",
+    sourceLanguage: ESourceLanguage.C,
+    sourceFile: "widget.h",
+    sourceLine: 2,
+    isExported: true,
+    type: "void (*)(widget_t*, const rect_t*, uint8_t*)",
+  });
+}
+
 describe("FunctionCallAnalyzer", () => {
   // ========================================================================
   // Define Before Use
@@ -1024,5 +1056,65 @@ describe("FunctionCallAnalyzer", () => {
         true,
       );
     });
+
+    it("should detect scope callback with this.member pattern (Issue #895 Bug A)", () => {
+      // Bug A: PR #897 only fixed global functions. Scope callbacks using
+      // this.cb pattern are not detected because extractFunctionReference
+      // does not handle the this keyword.
+      const code = `
+        scope ScopeAP {
+          public void cb(u32 w) {
+            u32 x <- w;
+          }
+
+          public void register_it() {
+            u32 w <- 0;
+            global.widget_set_flush_cb(w, this.cb);
+          }
+        }
+      `;
+      const tree = parse(code);
+      const symbolTable = new SymbolTable();
+      addWidgetCallbackSymbols(symbolTable);
+
+      CodeGenState.callbackCompatibleFunctions.clear();
+      const analyzer = new FunctionCallAnalyzer();
+      analyzer.analyze(tree, symbolTable);
+
+      // Should detect ScopeAP_cb as callback-compatible
+      expect(CodeGenState.callbackCompatibleFunctions.has("ScopeAP_cb")).toBe(
+        true,
+      );
+    });
+
+    it("should detect scope callback with global.Scope.member pattern (Issue #895 Bug A)", () => {
+      // Bug A: PR #897 only fixed global functions. Scope callbacks using
+      // global.ScopeName.member pattern are not detected because
+      // extractFunctionReference does not handle two-level dotted paths.
+      const code = `
+        scope ScopeAP {
+          public void cb(u32 w) {
+            u32 x <- w;
+          }
+        }
+
+        void register_from_global() {
+          u32 w <- 0;
+          global.widget_set_flush_cb(w, global.ScopeAP.cb);
+        }
+      `;
+      const tree = parse(code);
+      const symbolTable = new SymbolTable();
+      addWidgetCallbackSymbols(symbolTable);
+
+      CodeGenState.callbackCompatibleFunctions.clear();
+      const analyzer = new FunctionCallAnalyzer();
+      analyzer.analyze(tree, symbolTable);
+
+      // Should detect ScopeAP_cb as callback-compatible
+      expect(CodeGenState.callbackCompatibleFunctions.has("ScopeAP_cb")).toBe(
+        true,
+      );
+    });
   });
 });

package/src/transpiler/logic/symbols/c/__tests__/CResolver.integration.test.ts

@@ -572,6 +572,29 @@ describe("CResolver - Additional Edge Cases", () => {
     expect(result.symbols[0].name).toBe("getPtr");
     expect(result.symbols[0].kind).toBe("function");
   });
+
+  it("collects pointer return type from function prototype (Issue #895 Bug B)", () => {
+    const tree = TestHelpers.parseC(`widget_t *widget_create(int w, int h);`);
+    const result = CResolver.resolve(tree!, "test.h");
+
+    expect(result.symbols).toHaveLength(1);
+    const symbol = result.symbols[0];
+    expect(symbol.name).toBe("widget_create");
+    expect(symbol.kind).toBe("function");
+    if (symbol.kind === "function") {
+      expect(symbol.type).toBe("widget_t*");
+      expect(symbol.parameters).toHaveLength(2);
+    }
+  });
+
+  it("collects non-pointer return type correctly (Issue #895 Bug B)", () => {
+    const tree = TestHelpers.parseC(`int getValue();`);
+    const result = CResolver.resolve(tree!, "test.h");
+
+    if (result.symbols[0].kind === "function") {
+      expect(result.symbols[0].type).toBe("int");
+    }
+  });
 });
 
 describe("CResolver - Without SymbolTable", () => {

package/src/transpiler/logic/symbols/c/collectors/FunctionCollector.ts

@@ -2,9 +2,10 @@
  * FunctionCollector - Collects function symbols from C parse trees.
  */
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import type { FunctionDefinitionContext } from "../../../parser/c/grammar/CParser";
+import type {
+  DeclaratorContext,
+  FunctionDefinitionContext,
+} from "../../../parser/c/grammar/CParser";
 import type ICFunctionSymbol from "../../../../types/symbols/c/ICFunctionSymbol";
 import type ICParameterInfo from "../../../../types/symbols/c/ICParameterInfo";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
@@ -80,7 +81,7 @@ class FunctionCollector {
   static collectFromDeclaration(
     name: string,
     baseType: string,
-    declarator: any,
+    declarator: DeclaratorContext,
     sourceFile: string,
     line: number,
     isExtern: boolean,
@@ -89,6 +90,11 @@ class FunctionCollector {
       DeclaratorUtils.extractFunctionParameters(declarator),
     );
 
+    // Issue #895 Bug B: Check if declarator has pointer - means function returns pointer
+    // In C grammar: widget_t *func() has declarator with pointer() before directDeclarator
+    const hasPointer = declarator.pointer() !== null;
+    const returnType = hasPointer ? `${baseType}*` : baseType;
+
     return {
       kind: "function",
       name,
@@ -96,7 +102,7 @@ class FunctionCollector {
       sourceLine: line,
       sourceLanguage: ESourceLanguage.C,
       isExported: !isExtern,
-      type: baseType,
+      type: returnType,
       parameters: parameters.length > 0 ? parameters : undefined,
       isDeclaration: true,
     };

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -3834,6 +3834,7 @@ export default class CodeGenerator implements IOrchestrator {
         this._inferVariableType(varCtx, name),
       trackLocalVariable: (varCtx, name) =>
         this._trackLocalVariable(varCtx, name),
+      markVariableAsPointer: (name) => this._markVariableAsPointer(name),
       getStringConcatOperands: (concatCtx) =>
         this._getStringConcatOperands(concatCtx),
       getSubstringOperands: (substrCtx) =>
@@ -3845,27 +3846,161 @@ export default class CodeGenerator implements IOrchestrator {
 
   /**
    * Issue #696: Infer variable type, handling nullable C pointer types.
+   * Issue #895 Bug B: Infer pointer type from C function return type.
    */
   private _inferVariableType(
     ctx: Parser.VariableDeclarationContext,
     name: string,
   ): string {
-    let type = this.generateType(ctx.type());
+    const type = this.generateType(ctx.type());
 
-    // ADR-046: Handle nullable C pointer types (c_ prefix variables)
-    if (!name.startsWith("c_") || !ctx.expression()) {
+    if (!ctx.expression()) {
       return type;
     }
 
-    const exprText = ctx.expression()!.getText();
-    for (const funcName of NullCheckAnalyzer.getStructPointerFunctions()) {
-      if (exprText.includes(`${funcName}(`)) {
-        return `${type}*`;
+    // Issue #895 Bug B: Check if initializer is a C function call returning pointer
+    const pointerType = this._inferPointerTypeFromFunctionCall(
+      ctx.expression()!,
+      type,
+    );
+    if (pointerType) {
+      return pointerType;
+    }
+
+    // ADR-046: Handle nullable C pointer types (c_ prefix variables)
+    if (name.startsWith("c_")) {
+      const exprText = ctx.expression()!.getText();
+      for (const funcName of NullCheckAnalyzer.getStructPointerFunctions()) {
+        if (exprText.includes(`${funcName}(`)) {
+          return `${type}*`;
+        }
       }
     }
+
     return type;
   }
 
+  /**
+   * Issue #895 Bug B: Infer pointer type from C function return type.
+   * If initializer is a call to a C function that returns T*, and declared
+   * type is T, return T* instead of T.
+   */
+  private _inferPointerTypeFromFunctionCall(
+    expr: Parser.ExpressionContext,
+    declaredType: string,
+  ): string | null {
+    // Extract function name from C function call patterns
+    const funcName = this._extractCFunctionName(expr);
+    if (!funcName) {
+      return null;
+    }
+
+    // Look up C function in symbol table
+    const cFunc = CodeGenState.symbolTable?.getCSymbol(funcName);
+    if (cFunc?.kind !== "function") {
+      return null;
+    }
+
+    // Check if return type is a pointer to the declared type
+    const returnType = cFunc.type;
+    if (!returnType.endsWith("*")) {
+      return null;
+    }
+
+    // Check if the base return type matches the declared type
+    // e.g., "widget_t *" or "widget_t*" matches declared "widget_t"
+    const returnBaseType = returnType.replace(/\s*\*\s*$/, "").trim();
+    if (returnBaseType === declaredType) {
+      return `${declaredType}*`;
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract C function name from expression patterns.
+   * Handles both:
+   * - global.funcName(...) - explicit global access
+   * - funcName(...) - direct call (if funcName is a known C function)
+   * Returns null if expression doesn't match these patterns.
+   */
+  private _extractCFunctionName(expr: Parser.ExpressionContext): string | null {
+    const postfix = ExpressionUnwrapper.getPostfixExpression(expr);
+    if (!postfix) {
+      return null;
+    }
+
+    const primary = postfix.primaryExpression();
+    const ops = postfix.postfixOp();
+
+    // Pattern 1: global.funcName(...)
+    if (primary.GLOBAL()) {
+      return this._extractGlobalPatternFuncName(ops);
+    }
+
+    // Pattern 2: funcName(...) - direct call
+    const identifier = primary.IDENTIFIER();
+    if (identifier) {
+      return this._extractDirectCallFuncName(identifier.getText(), ops);
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract function name from global.funcName(...) pattern.
+   */
+  private _extractGlobalPatternFuncName(
+    ops: Parser.PostfixOpContext[],
+  ): string | null {
+    if (ops.length < 2) {
+      return null;
+    }
+
+    const memberOp = ops[0];
+    if (!memberOp.IDENTIFIER()) {
+      return null;
+    }
+
+    const callOp = ops[1];
+    if (!this._isCallOp(callOp)) {
+      return null;
+    }
+
+    return memberOp.IDENTIFIER()!.getText();
+  }
+
+  /**
+   * Extract function name from direct funcName(...) call if it's a C function.
+   */
+  private _extractDirectCallFuncName(
+    funcName: string,
+    ops: Parser.PostfixOpContext[],
+  ): string | null {
+    if (ops.length < 1) {
+      return null;
+    }
+
+    if (!this._isCallOp(ops[0])) {
+      return null;
+    }
+
+    // Verify this is actually a C function (not a C-Next scope function)
+    const cFunc = CodeGenState.symbolTable?.getCSymbol(funcName);
+    if (cFunc?.kind === "function") {
+      return funcName;
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if a postfix op is a function call.
+   */
+  private _isCallOp(op: Parser.PostfixOpContext): boolean {
+    return Boolean(op.argumentList() || op.getText().startsWith("("));
+  }
+
   /**
    * Issue #696: Track local variable for type registry and const values.
    */
@@ -3893,6 +4028,21 @@ export default class CodeGenerator implements IOrchestrator {
     }
   }
 
+  /**
+   * Issue #895 Bug B: Mark variable as a pointer in the type registry.
+   * Called when type inference detects that a variable should be a pointer
+   * (e.g., initialized from a C function returning T*).
+   */
+  private _markVariableAsPointer(name: string): void {
+    const typeInfo = CodeGenState.getVariableTypeInfo(name);
+    if (typeInfo) {
+      CodeGenState.setVariableTypeInfo(name, {
+        ...typeInfo,
+        isPointer: true,
+      });
+    }
+  }
+
   // Issue #792: Methods _handleArrayDeclaration, _getArrayTypeDimension, _parseArrayTypeDimension,
   // _parseFirstArrayDimension, _validateArrayDeclarationSyntax, _extractBaseTypeName,
   // _generateVariableInitializer, _validateIntegerInitializer, _finalizeCppClassAssignments,

package/src/transpiler/output/codegen/__tests__/CodeGenerator.coverage.test.ts

@@ -17,6 +17,7 @@ import SymbolTable from "../../../logic/symbols/SymbolTable";
 import CNextResolver from "../../../logic/symbols/cnext/index";
 import TSymbolInfoAdapter from "../../../logic/symbols/cnext/adapters/TSymbolInfoAdapter";
 import CodeGenState from "../../../state/CodeGenState";
+import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
 
 /**
  * Helper to parse C-Next source and return tree + generator ready for testing.
@@ -1209,4 +1210,132 @@ describe("CodeGenerator Coverage Tests", () => {
       expect(code).toContain("cnx_clamp_add_u8");
     });
   });
+
+  // ==========================================================================
+  // Issue #895 Bug B: Pointer type inference from C function calls
+  // ==========================================================================
+  describe("_inferPointerTypeFromFunctionCall / _extractCFunctionName", () => {
+    /**
+     * Helper to setup generator with C symbols added to SymbolTable.
+     */
+    function setupGeneratorWithCSymbols(
+      source: string,
+      cSymbols: Array<{
+        name: string;
+        type: string;
+        sourceFile: string;
+      }>,
+    ): string {
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+
+      const symbolTable = new SymbolTable();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      symbolTable.addTSymbols(tSymbols);
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      // Add C function symbols
+      for (const cSym of cSymbols) {
+        symbolTable.addCSymbol({
+          kind: "function",
+          name: cSym.name,
+          type: cSym.type,
+          sourceFile: cSym.sourceFile,
+          sourceLine: 1,
+          sourceLanguage: ESourceLanguage.C,
+          isExported: true,
+          isDeclaration: true,
+        });
+      }
+
+      const generator = new CodeGenerator();
+      CodeGenState.symbolTable = symbolTable;
+
+      return generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+        cppMode: false,
+      });
+    }
+
+    it("should infer pointer type from global.funcName() pattern", () => {
+      const source = `
+        void test() {
+          widget_t w <- global.widget_create();
+        }
+      `;
+
+      const code = setupGeneratorWithCSymbols(source, [
+        { name: "widget_create", type: "widget_t*", sourceFile: "widget.h" },
+      ]);
+
+      // Should generate widget_t* w (pointer), not widget_t w
+      expect(code).toContain("widget_t* w = widget_create()");
+    });
+
+    it("should infer pointer type from direct funcName() call", () => {
+      const source = `
+        void test() {
+          widget_t w <- widget_create();
+        }
+      `;
+
+      const code = setupGeneratorWithCSymbols(source, [
+        { name: "widget_create", type: "widget_t*", sourceFile: "widget.h" },
+      ]);
+
+      // Should generate widget_t* w (pointer), not widget_t w
+      expect(code).toContain("widget_t* w = widget_create()");
+    });
+
+    it("should not infer pointer when C function returns non-pointer", () => {
+      const source = `
+        void test() {
+          i32 val <- global.get_value();
+        }
+      `;
+
+      const code = setupGeneratorWithCSymbols(source, [
+        { name: "get_value", type: "int", sourceFile: "utils.h" },
+      ]);
+
+      // Should generate int32_t val (not a pointer)
+      expect(code).toContain("int32_t val = get_value()");
+      expect(code).not.toContain("int32_t* val");
+    });
+
+    it("should not infer pointer when function is not a C function", () => {
+      // No C symbols registered - create_widget is a C-Next function
+      const source = `
+        struct widget_t { i32 x; }
+        widget_t create_widget() {
+          widget_t dummy <- {x: 0};
+          return dummy;
+        }
+        void test() {
+          widget_t w <- create_widget();
+        }
+      `;
+
+      const { code } = setupGenerator(source);
+
+      // Should NOT generate pointer since create_widget is a C-Next function
+      expect(code).not.toContain("widget_t* w");
+    });
+
+    it("should not infer pointer when return type base doesn't match declared type", () => {
+      const source = `
+        void test() {
+          widget_t w <- global.create_other();
+        }
+      `;
+
+      const code = setupGeneratorWithCSymbols(source, [
+        { name: "create_other", type: "other_t*", sourceFile: "other.h" },
+      ]);
+
+      // Should NOT infer pointer since types don't match
+      // (other_t* doesn't match widget_t)
+      expect(code).not.toContain("widget_t* w");
+    });
+  });
 });