c-next 0.2.16 → 0.2.18

package/src/transpiler/__tests__/compileCommandsDiscovery.integration.test.ts

@@ -0,0 +1,94 @@
+/**
+ * Integration test: auto-discovery of compile_commands.json.
+ *
+ * cnext resolves external C/C++ headers exactly as the compiler will by reading
+ * the build-system-agnostic contract every build system emits — the
+ * `compile_commands.json` compilation database — from the project root, the way
+ * clangd does. This proves the wiring end-to-end: a header reachable ONLY through
+ * the compile database's `-I` (never passed via includeDirs / cnext.config.json)
+ * must resolve during a real transpile, and its pointer-parameter signature must
+ * drive `&` codegen.
+ *
+ * Requires a C preprocessor toolchain; skips gracefully when none is available.
+ */
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import {
+  mkdtempSync,
+  writeFileSync,
+  mkdirSync,
+  rmSync,
+  readFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import Transpiler from "../Transpiler";
+import Preprocessor from "../logic/preprocessor/Preprocessor";
+
+const WIDGET_H = `typedef struct { int mode; } widget_cfg_t;
+void widget_do(const widget_cfg_t *cfg);
+`;
+
+const MAIN_CNX = `#include <widget.h>
+
+scope Demo {
+  void run() {
+    widget_cfg_t cfg <- {mode: 1};
+    global.widget_do(cfg);
+  }
+}
+`;
+
+describe("compile_commands.json auto-discovery (integration)", () => {
+  let dir: string;
+  const available = new Preprocessor().isAvailable();
+
+  beforeAll(() => {
+    dir = mkdtempSync(join(tmpdir(), "cnext-cc-discovery-"));
+    mkdirSync(join(dir, "ext"));
+    writeFileSync(join(dir, "ext", "widget.h"), WIDGET_H);
+    writeFileSync(join(dir, "main.cnx"), MAIN_CNX);
+    // Project-root marker so discovery locates the database.
+    writeFileSync(join(dir, "cnext.config.json"), "{}\n");
+    // The compiler's own view: <widget.h> is reachable ONLY via this -I.
+    writeFileSync(
+      join(dir, "compile_commands.json"),
+      JSON.stringify([
+        {
+          directory: dir,
+          file: join(dir, "main.cpp"),
+          command: `cc -I${join(dir, "ext")} -c main.cpp`,
+        },
+      ]),
+    );
+  });
+
+  afterAll(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("resolves a header supplied only by the compile database", async () => {
+    if (!available) return; // no toolchain in this env
+
+    // Note: NO includeDirs — the ext/ path exists solely in compile_commands.json.
+    const transpiler = new Transpiler({
+      input: join(dir, "main.cnx"),
+      outDir: join(dir, "out"),
+      cppRequired: true,
+      noCache: true,
+    });
+
+    const result = await transpiler.transpile({ kind: "files" });
+
+    const unresolved = result.errors.find((e) =>
+      e.message.includes("widget_do"),
+    );
+    expect(unresolved).toBeUndefined();
+    expect(result.success).toBe(true);
+
+    const generated = result.outputFiles.find((f) => f.endsWith("main.cpp"));
+    expect(generated).toBeDefined();
+    const code = readFileSync(generated!, "utf8");
+    // Pointer-parameter signature (from the compile-db-supplied header) -> `&`.
+    expect(code).toMatch(/widget_do\(\s*&/);
+  });
+});

package/src/transpiler/__tests__/externalSymbolRecovery.integration.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Integration test for Issue #985 external-symbol recovery.
+ *
+ * Drives the real Transpiler over a fixture that forces the recovery path:
+ * widget.h refuses standalone inclusion (its #error fires unless guard.h ran
+ * first), its API is emitted by a guard.h macro and decorated with a trailing
+ * attribute macro, and it declares a pointer-parameter function plus an opaque
+ * handle. This exercises Transpiler._collectExternalDeclarations and its
+ * helpers, ExternalDeclarationOracle, and the downstream codegen that adds `&`
+ * for a struct passed to a pointer param and `*` for an opaque handle.
+ *
+ * Requires a C preprocessor toolchain; skips gracefully when none is available.
+ */
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import Transpiler from "../Transpiler";
+import CodeGenState from "../state/CodeGenState";
+import Preprocessor from "../logic/preprocessor/Preprocessor";
+
+const GUARD_H = `#define WIDGET_GUARD 1
+#define WIDGET_FEATURE 1
+#define USE_PTHREAD 0
+#define PRIVILEGED
+#define WIDGET_SCALE(x) ((x) + 1)
+#define DECLARE_WIDGET_API \\
+  typedef struct _widget_t widget_t; \\
+  typedef struct { int mode; } widget_cfg_t; \\
+  extern const widget_cfg_t widget_default_cfg; \\
+  int widget_install(const widget_cfg_t *config) PRIVILEGED; \\
+  void widget_apply(const widget_cfg_t *cfg) PRIVILEGED; \\
+  widget_t *widget_create(void) PRIVILEGED;
+`;
+
+// A header cnext DISCOVERS (it walks #includes unconditionally) but that cannot
+// preprocess standalone — its <no-such-header> mirrors lvgl's OSAL headers
+// probing <semaphore.h>. Its standalone failure sets anyHeaderPreprocessFailed,
+// which is what triggers the external-declaration recovery pass. It is guarded
+// out of the recovery TU (USE_PTHREAD is 0), so the union still preprocesses.
+const PTHREAD_IMPL_H = `#include <cnext_no_such_header_zzz.h>\n`;
+
+const WIDGET_H = `#ifndef WIDGET_GUARD
+#error "include guard.h before widget.h"
+#endif
+#if USE_PTHREAD
+#include "pthread_impl.h"
+#endif
+#if WIDGET_FEATURE
+DECLARE_WIDGET_API
+#endif
+`;
+
+const MAIN_CNX = `#include "guard.h"
+#include "widget.h"
+
+scope Demo {
+  widget_t handle;
+
+  void build() {
+    widget_cfg_t cfg <- {mode: 1};
+    i32 err <- global.widget_install(cfg);
+    global.widget_apply(widget_default_cfg);
+    i32 scaled <- WIDGET_SCALE(4);
+    handle <- global.widget_create();
+  }
+}
+`;
+
+describe("external-symbol recovery (integration)", () => {
+  let dir: string;
+  const available = new Preprocessor().isAvailable();
+
+  beforeAll(() => {
+    dir = mkdtempSync(join(tmpdir(), "cnext-recovery-"));
+    writeFileSync(join(dir, "guard.h"), GUARD_H);
+    writeFileSync(join(dir, "widget.h"), WIDGET_H);
+    writeFileSync(join(dir, "pthread_impl.h"), PTHREAD_IMPL_H);
+    writeFileSync(join(dir, "main.cnx"), MAIN_CNX);
+  });
+
+  afterAll(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("recovers full signatures so codegen adds & and pointer handles", async () => {
+    if (!available) return; // no toolchain in this env
+
+    const transpiler = new Transpiler({
+      input: join(dir, "main.cnx"),
+      includeDirs: [dir],
+      outDir: join(dir, "out"),
+      cppRequired: true,
+      noCache: true,
+    });
+
+    const result = await transpiler.transpile({ kind: "files" });
+
+    const unresolved = result.errors.find(
+      (e) =>
+        e.message.includes("widget_install") ||
+        e.message.includes("widget_create") ||
+        // Function-like macro recovered by name (no declaration to parse).
+        e.message.includes("WIDGET_SCALE"),
+    );
+    expect(unresolved).toBeUndefined();
+    expect(result.success).toBe(true);
+
+    const generated = result.outputFiles.find((f) => f.endsWith("main.cpp"));
+    expect(generated).toBeDefined();
+    const code = readFileSync(generated!, "utf8");
+
+    // Local struct arg passed to a pointer param -> address-of.
+    expect(code).toMatch(/widget_install\(\s*&/);
+    // Extern C global (struct value) passed to a pointer param -> address-of,
+    // resolved via the C symbol table fallback (#985).
+    expect(code).toMatch(/widget_apply\(\s*&widget_default_cfg/);
+    // Opaque handle -> pointer field.
+    expect(code).toMatch(/widget_t\s*\*\s*\w*handle/);
+  });
+
+  it("folds a recovered struct into externalStructFields so it stays subject to init-completeness checking", async () => {
+    if (!available) return;
+
+    // widget_cfg_t only becomes known through #985 recovery (its typedef is
+    // emitted by the DECLARE_WIDGET_API macro inside the un-standalone header).
+    // The external-struct snapshot InitializationAnalyzer consults must include
+    // it — otherwise recovered structs escape init checking that cleanly
+    // preprocessed structs get. Regression: the snapshot must be taken AFTER the
+    // recovery pass, not before it.
+    const transpiler = new Transpiler({
+      input: join(dir, "main.cnx"),
+      includeDirs: [dir],
+      outDir: join(dir, "out"),
+      cppRequired: true,
+      noCache: true,
+    });
+
+    const result = await transpiler.transpile({ kind: "files" });
+    expect(result.success).toBe(true);
+
+    const external = CodeGenState.getExternalStructFields();
+    expect(external.has("widget_cfg_t")).toBe(true);
+    expect([...(external.get("widget_cfg_t") ?? [])]).toContain("mode");
+  });
+
+  it("re-applies recovery on a warm header cache (Issue #985 regression)", async () => {
+    if (!available) return;
+
+    // Fresh project dir with a project marker so on-disk caching activates
+    // (determineProjectRoot needs a marker like cnext.config.json). The first
+    // run populates .cnx/ with the DEGRADED header symbols (cached before the
+    // recovery pass runs); the second run restores them from cache. The
+    // recovery gate must survive caching so warm builds re-apply the fix.
+    const cacheDir = mkdtempSync(join(tmpdir(), "cnext-recovery-cache-"));
+    try {
+      writeFileSync(join(cacheDir, "cnext.config.json"), "{}\n");
+      writeFileSync(join(cacheDir, "guard.h"), GUARD_H);
+      writeFileSync(join(cacheDir, "widget.h"), WIDGET_H);
+      writeFileSync(join(cacheDir, "pthread_impl.h"), PTHREAD_IMPL_H);
+      writeFileSync(join(cacheDir, "main.cnx"), MAIN_CNX);
+
+      // Caching ON (noCache defaults to false).
+      const run = async () =>
+        new Transpiler({
+          input: join(cacheDir, "main.cnx"),
+          includeDirs: [cacheDir],
+          outDir: join(cacheDir, "out"),
+          cppRequired: true,
+        }).transpile({ kind: "files" });
+
+      // Cold cache: populates .cnx/ with the degraded header symbols.
+      const cold = await run();
+      expect(cold.success).toBe(true);
+
+      // Warm cache: headers unchanged and restored from cache. The recovery
+      // pass must still fire and produce the same corrected codegen — before
+      // the fix, the warm build regenerated the by-value / non-compiling output.
+      const warm = await run();
+      expect(warm.success).toBe(true);
+
+      const generated = warm.outputFiles.find((f) => f.endsWith("main.cpp"));
+      expect(generated).toBeDefined();
+      const code = readFileSync(generated!, "utf8");
+      expect(code).toMatch(/widget_install\(\s*&/);
+      expect(code).toMatch(/widget_apply\(\s*&widget_default_cfg/);
+      expect(code).toMatch(/widget_t\s*\*\s*\w*handle/);
+    } finally {
+      rmSync(cacheDir, { recursive: true, force: true });
+    }
+  });
+
+  it("does nothing when no header failed to preprocess (clean project)", async () => {
+    if (!available) return;
+
+    // A .cnx with no C includes never trips anyHeaderPreprocessFailed, so the
+    // recovery pass is a no-op and transpilation still succeeds.
+    const cleanDir = mkdtempSync(join(tmpdir(), "cnext-clean-"));
+    try {
+      writeFileSync(
+        join(cleanDir, "main.cnx"),
+        `scope Demo {\n  void run() {\n    i32 x <- 1;\n  }\n}\n`,
+      );
+      const transpiler = new Transpiler({
+        input: join(cleanDir, "main.cnx"),
+        outDir: join(cleanDir, "out"),
+        noCache: true,
+      });
+      const result = await transpiler.transpile({ kind: "files" });
+      expect(result.success).toBe(true);
+    } finally {
+      rmSync(cleanDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/transpiler/logic/__tests__/detectAssemblySyntax.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Unit tests for detectAssemblySyntax
+ *
+ * Some framework headers (e.g. xtensa `coreasm.h`, pulled in transitively by
+ * FreeRTOS port headers) are GNU-assembler sources, not C: they `#define
+ * _ASMLANGUAGE` and contain `.macro` bodies whose instruction mnemonics (e.g.
+ * `loop`) were mis-collected as C symbols, causing false "defined in multiple
+ * languages" conflicts against C-Next symbols like Arduino `loop()`.
+ * detectAssemblySyntax lets the header pipeline skip such files.
+ */
+import { describe, it, expect } from "vitest";
+import detectAssemblySyntax from "../detectAssemblySyntax";
+
+describe("detectAssemblySyntax", () => {
+  describe("assembler sources - should return true", () => {
+    it("detects a GAS .macro block (xtensa coreasm.h shape)", () => {
+      const coreasm = [
+        "#define _ASMLANGUAGE",
+        "\t.macro\tfloop_\tar, startlabel, endlabelref",
+        "\tloop\t\\ar, \\endlabelref",
+        "\t.endm",
+      ].join("\n");
+      expect(detectAssemblySyntax(coreasm)).toBe(true);
+    });
+
+    it("detects the _ASMLANGUAGE marker on its own", () => {
+      expect(detectAssemblySyntax("#define _ASMLANGUAGE 1\n")).toBe(true);
+    });
+
+    it("detects section/global directives at line start", () => {
+      expect(detectAssemblySyntax("  .section .text\n  .global _start\n")).toBe(
+        true,
+      );
+    });
+
+    it("detects .macro regardless of leading whitespace", () => {
+      expect(detectAssemblySyntax("    .macro find_ms_setbit ad, as\n")).toBe(
+        true,
+      );
+    });
+
+    it("detects a spaced '# define _ASMLANGUAGE' directive", () => {
+      expect(detectAssemblySyntax("# define _ASMLANGUAGE\n")).toBe(true);
+    });
+
+    it("detects portable assembly markers defined whole-file", () => {
+      expect(detectAssemblySyntax("#define __ASSEMBLY__ 1\n")).toBe(true);
+      expect(detectAssemblySyntax("#define __ASSEMBLER__\n")).toBe(true);
+    });
+  });
+
+  describe("C / C++ headers - should return false", () => {
+    it("returns false for a C function named loop", () => {
+      expect(
+        detectAssemblySyntax("void loop(void);\nint add(int a, int b);"),
+      ).toBe(false);
+    });
+
+    it("returns false for structs, enums, typedefs", () => {
+      expect(
+        detectAssemblySyntax(
+          "typedef struct { int x; } Point;\nenum Color { RED, GREEN };",
+        ),
+      ).toBe(false);
+    });
+
+    it("does not false-positive on member access or identifiers containing 'macro'", () => {
+      expect(
+        detectAssemblySyntax("int y = p.x;\nint n = cfg.macro_count;"),
+      ).toBe(false);
+    });
+
+    it("returns false for a C++ class header", () => {
+      expect(
+        detectAssemblySyntax("class Foo : public Bar { public: int x; };"),
+      ).toBe(false);
+    });
+
+    it("returns false for a C header that guards prototypes with #ifndef _ASMLANGUAGE", () => {
+      // xtensa xtruntime.h shape: raw-fallback content still holds the guard
+      // line. The C prototypes inside must NOT be dropped as assembler.
+      const xtruntime = [
+        "#ifndef _ASMLANGUAGE",
+        "extern void xthal_window_spill(void);",
+        "extern unsigned xthal_get_ccount(void);",
+        "#endif",
+      ].join("\n");
+      expect(detectAssemblySyntax(xtruntime)).toBe(false);
+    });
+
+    it("returns false for a C header guarded by #ifndef __ASSEMBLY__ / #ifdef __ASSEMBLER__", () => {
+      // Linux-kernel-style guards fence the C prototypes; on the raw-fallback
+      // path the guard lines survive but the file is still a normal C header.
+      const guarded = [
+        "#ifndef __ASSEMBLY__",
+        "extern int kernel_init(void);",
+        "#endif",
+        "#ifdef __ASSEMBLER__",
+        "/* asm-only region */",
+        "#endif",
+      ].join("\n");
+      expect(detectAssemblySyntax(guarded)).toBe(false);
+    });
+
+    it("does not match a longer macro name that merely starts with _ASMLANGUAGE", () => {
+      // Exact-token match: `#define _ASMLANGUAGE_CONFIG 1` is not the marker.
+      expect(detectAssemblySyntax("#define _ASMLANGUAGE_CONFIG 1\n")).toBe(
+        false,
+      );
+    });
+
+    it("returns false for empty content", () => {
+      expect(detectAssemblySyntax("")).toBe(false);
+    });
+  });
+});

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

@@ -315,7 +315,10 @@ class FunctionCallListener extends CNextListener {
     if (!baseName) return;
 
     // Walk through postfix ops to find the call and resolve the name
-    const { resolvedName, foundCall } = this.resolveCallTarget(ops, baseName);
+    const { resolvedName, foundCall, isGlobalCall } = this.resolveCallTarget(
+      ops,
+      baseName,
+    );
     if (!foundCall) return;
 
     // Check if the function is defined
@@ -325,6 +328,7 @@ class FunctionCallListener extends CNextListener {
       line,
       column,
       this.currentScope,
+      isGlobalCall,
     );
   };
 
@@ -340,6 +344,9 @@ class FunctionCallListener extends CNextListener {
     if (primary.THIS()) {
       return "this";
     }
+    if (primary.GLOBAL()) {
+      return "global";
+    }
     return null;
   }
 
@@ -351,15 +358,21 @@ class FunctionCallListener extends CNextListener {
   private resolveCallTarget(
     ops: Parser.PostfixOpContext[],
     baseName: string,
-  ): { resolvedName: string; foundCall: boolean } {
+  ): { resolvedName: string; foundCall: boolean; isGlobalCall: boolean } {
     let resolvedName = baseName;
+    let isGlobalCall = baseName === "global";
 
     for (const op of ops) {
       // Member access: check if it's Scope.member or this.member pattern
       if (op.IDENTIFIER()) {
         const resolved = this.resolveMemberAccess(resolvedName, op);
         if (resolved === null) {
-          return { resolvedName, foundCall: false };
+          return { resolvedName, foundCall: false, isGlobalCall };
+        }
+        // If resolution went through a known scope, this is a scope
+        // method call, not a global function lookup
+        if (isGlobalCall && this.analyzer.isScope(resolvedName)) {
+          isGlobalCall = false;
         }
         resolvedName = resolved;
         continue;
@@ -369,12 +382,12 @@ class FunctionCallListener extends CNextListener {
       if (op.argumentList() || op.getChildCount() === 2) {
         const text = op.getText();
         if (text.startsWith("(")) {
-          return { resolvedName, foundCall: true };
+          return { resolvedName, foundCall: true, isGlobalCall };
         }
       }
     }
 
-    return { resolvedName, foundCall: false };
+    return { resolvedName, foundCall: false, isGlobalCall };
   }
 
   /**
@@ -391,6 +404,11 @@ class FunctionCallListener extends CNextListener {
       return `${this.currentScope}_${memberName}`;
     }
 
+    // Issue #985: Handle global.member -> member (strip global prefix)
+    if (resolvedName === "global") {
+      return memberName;
+    }
+
     // Check if base is a known scope
     if (this.analyzer.isScope(resolvedName)) {
       return `${resolvedName}_${memberName}`;
@@ -934,12 +952,14 @@ class FunctionCallAnalyzer {
    * @param line Source line number
    * @param column Source column number
    * @param currentScope The current scope name (if inside a scope)
+   * @param isGlobalCall Whether the call used global. prefix
    */
   public checkFunctionCall(
     name: string,
     line: number,
     column: number,
     currentScope: string | null,
+    isGlobalCall: boolean = false,
   ): void {
     // Check for self-recursion (MISRA C:2012 Rule 17.2)
     if (this.currentFunctionName && name === this.currentFunctionName) {
@@ -981,7 +1001,8 @@ class FunctionCallAnalyzer {
     // ADR-057: Allow implicit scope function calls without this. prefix
     // Check if this is an unqualified call to a scope function
     // e.g., calling helper() instead of this.helper() inside a scope
-    if (currentScope) {
+    // Skip for global. calls — global. explicitly means global scope
+    if (currentScope && !isGlobalCall) {
       const qualifiedName = `${currentScope}_${name}`;
       if (this.definedFunctions.has(qualifiedName)) {
         return; // OK - implicit resolution will handle it
@@ -989,11 +1010,15 @@ class FunctionCallAnalyzer {
     }
 
     // Not defined - report error with optional hint
+    // If the function is local (defined later in this file), it's a
+    // define-before-use error regardless of global. prefix
+    const isLocalFunction = this.allLocalFunctions.has(name);
     const header = this.findStdlibHeader(name);
-    let message = `function '${name}' called before definition`;
-    if (header) {
-      message += `; hint: '${name}' is available from ${header} — try global.${name}()`;
-    }
+    const message = this.buildUndefinedFunctionMessage(
+      name,
+      header,
+      isGlobalCall && !isLocalFunction,
+    );
 
     this.errors.push({
       code: "E0422",
@@ -1004,6 +1029,28 @@ class FunctionCallAnalyzer {
     });
   }
 
+  /**
+   * Issue #985: Build error message for undefined function calls.
+   * Adjusts hint based on whether the call used global. prefix.
+   */
+  private buildUndefinedFunctionMessage(
+    name: string,
+    header: string | null,
+    isGlobalCall: boolean,
+  ): string {
+    if (isGlobalCall && header) {
+      return `'${name}' is not declared in any included header; add #include <${header}>`;
+    }
+    if (isGlobalCall) {
+      return `'${name}' is not declared in any included header`;
+    }
+    let message = `function '${name}' called before definition`;
+    if (header) {
+      message += `; hint: '${name}' is available from ${header} — try global.${name}()`;
+    }
+    return message;
+  }
+
   /**
    * Check if a function is defined externally (from included files)
    * This includes C/C++ headers AND C-Next includes.
@@ -1033,6 +1080,14 @@ class FunctionCallAnalyzer {
       }
     }
 
+    // Issue #985 recovery: a function-like MACRO recovered by translation-unit
+    // preprocessing (e.g. FreeRTOS pdMS_TO_TICKS). Recovered functions are
+    // registered as full symbols (found above via getOverloads); macros have no
+    // declaration to parse, so only their name is known.
+    if (this.symbolTable.hasExternalDeclaration(name)) {
+      return true;
+    }
+
     return false;
   }
 }