c-next 0.2.17 → 0.2.18

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

@@ -1080,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;
   }
 }