Fix assert support when assert.h is included after c2pulse.h

Agent-Logs-Url: https://github.com/FStarLang/c2pulse/sessions/9442fd81-5e97-4ff4-a291-37a621de7e8f

Co-authored-by: gebner <313929+gebner@users.noreply.github.com>

Author: Copilot

cpp/impl.cpp

@@ -1563,6 +1563,54 @@ std::string getResourcesPath() {
   return GetResourcesPath(getBinaryForResourcesPath());
 }
 
+// --- Builtin virtual include directory ---
+// c2pulse injects a wrapper assert.h so that #include <assert.h> always
+// results in assert() being translated to __c2pulse_c_assert(), regardless
+// of whether assert.h is included before or after c2pulse.h.
+static const char BUILTIN_INCLUDE_DIR[] = "/c2pulse_builtins";
+static const char BUILTIN_ASSERT_H_PATH[] = "/c2pulse_builtins/assert.h";
+// The wrapper uses #include_next to pull in the real system assert.h and then
+// re-overrides the assert macro so c2pulse can always intercept assert() calls.
+static const char BUILTIN_ASSERT_H_CONTENT[] =
+    "#include_next <assert.h>\n"
+    "#ifdef C2PULSE\n"
+    "#undef assert\n"
+    "#define assert(x) __c2pulse_c_assert(x)\n"
+    "#endif\n";
+
+// Stable unique IDs for builtin virtual filesystem entries (device 2 to avoid
+// collisions with real files which use device 0).
+static const llvm::sys::fs::UniqueID BUILTIN_ASSERT_H_UID(2, 1);
+static const llvm::sys::fs::UniqueID BUILTIN_INCLUDE_DIR_UID(2, 2);
+
+// A VFS file that serves static string content (used for builtin headers).
+class BuiltinVFSFile : public llvm::vfs::File {
+  llvm::StringRef name;
+  llvm::StringRef content;
+
+public:
+  BuiltinVFSFile(llvm::StringRef n, llvm::StringRef c) : name(n), content(c) {}
+
+  llvm::ErrorOr<llvm::vfs::Status> status() override {
+    llvm::sys::TimePoint<> time;
+    return llvm::vfs::Status(
+        name, BUILTIN_ASSERT_H_UID, time, 0, 0, content.size(),
+        llvm::sys::fs::file_type::regular_file, llvm::sys::fs::perms::all_all);
+  }
+
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
+  getBuffer(const Twine &Name, int64_t FileSize = -1,
+            bool RequiresNullTerminator = true,
+            bool IsVolatile = false) override {
+    if (!RequiresNullTerminator)
+      return llvm::MemoryBuffer::getMemBuffer(content, name);
+    return llvm::MemoryBuffer::getMemBufferCopy(content, name);
+  }
+
+  std::error_code close() override { return {}; }
+  llvm::ErrorOr<std::string> getName() override { return name.str(); }
+};
+
 llvm::vfs::Status mkStatus(Ref<rust::crate::vfs::VFSEntry> entry) {
   auto fileName = entry.get_file_name();
   llvm::sys::fs::UniqueID unique(0, (uint64_t)fileName.as_ptr());
@@ -1607,6 +1655,14 @@ class CtxVFS : public llvm::vfs::FileSystem {
   RefMut<Ctx> ctx;
   IntrusiveRefCntPtr<llvm::vfs::FileSystem> realFS;
 
+  static bool isBuiltinFile(llvm::StringRef path) {
+    return path == BUILTIN_ASSERT_H_PATH;
+  }
+
+  static bool isBuiltinDir(llvm::StringRef path) {
+    return path == BUILTIN_INCLUDE_DIR;
+  }
+
 public:
   CtxVFS(RefMut<Ctx> c) : ctx(c), realFS(llvm::vfs::getRealFileSystem()) {}
 
@@ -1615,7 +1671,22 @@ class CtxVFS : public llvm::vfs::FileSystem {
   }
 
   llvm::ErrorOr<llvm::vfs::Status> status(const Twine &Path) override {
-    auto res = ctx.read_vfs_file(toStr(Path.str()));
+    auto pathStr = Path.str();
+    if (isBuiltinFile(pathStr)) {
+      llvm::sys::TimePoint<> time;
+      return llvm::vfs::Status(BUILTIN_ASSERT_H_PATH, BUILTIN_ASSERT_H_UID,
+                               time, 0, 0, sizeof(BUILTIN_ASSERT_H_CONTENT) - 1,
+                               llvm::sys::fs::file_type::regular_file,
+                               llvm::sys::fs::perms::all_all);
+    }
+    if (isBuiltinDir(pathStr)) {
+      llvm::sys::TimePoint<> time;
+      return llvm::vfs::Status(BUILTIN_INCLUDE_DIR, BUILTIN_INCLUDE_DIR_UID,
+                               time, 0, 0, 0,
+                               llvm::sys::fs::file_type::directory_file,
+                               llvm::sys::fs::perms::all_all);
+    }
+    auto res = ctx.read_vfs_file(toStr(pathStr));
     if (!res.is_ok()) {
       // TODO: fallback for directories
       return realFS->status(Path);
@@ -1625,6 +1696,12 @@ class CtxVFS : public llvm::vfs::FileSystem {
 
   llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>
   openFileForRead(const Twine &Path) override {
+    if (isBuiltinFile(Path.str())) {
+      return std::make_unique<BuiltinVFSFile>(
+          llvm::StringRef(BUILTIN_ASSERT_H_PATH),
+          llvm::StringRef(BUILTIN_ASSERT_H_CONTENT,
+                          sizeof(BUILTIN_ASSERT_H_CONTENT) - 1));
+    }
     auto res = ctx.read_vfs_file(toStr(Path.str()));
     if (!res.is_ok()) {
       return llvm::errc::no_such_file_or_directory;
@@ -1652,7 +1729,10 @@ class CtxVFS : public llvm::vfs::FileSystem {
   }
 
   bool exists(const Twine &Path) override {
-    auto res = ctx.read_vfs_file(toStr(Path.str()));
+    auto pathStr = Path.str();
+    if (isBuiltinFile(pathStr) || isBuiltinDir(pathStr))
+      return true;
+    auto res = ctx.read_vfs_file(toStr(pathStr));
     if (res.is_ok())
       return true;
 
@@ -1705,6 +1785,12 @@ static void parse_file(RefMut<Ctx> ctx) {
         incPath.c_str(), ArgumentInsertPosition::BEGIN));
   }
 
+  // Add the builtin include directory last so it ends up first in the
+  // command line (highest priority). This ensures our wrapper assert.h
+  // is found before any system assert.h.
+  Tool.appendArgumentsAdjuster(getInsertArgumentAdjuster(
+      {"-I", BUILTIN_INCLUDE_DIR}, ArgumentInsertPosition::BEGIN));
+
   C2PulseActionFactory factory(ctx, rangeMap);
   Tool.run(&factory);
 }