fuzzprep 0.1.0__py3-none-any.whl

fuzzprep/feature_extractor/native/src/extraction_action.cpp

@@ -0,0 +1,294 @@
+#include "feature_extractor.hpp"
+
+#include <clang/AST/ASTConsumer.h>
+#include <clang/AST/Decl.h>
+#include <clang/AST/DeclCXX.h>
+#include <clang/AST/RecursiveASTVisitor.h>
+#include <clang/Frontend/CompilerInstance.h>
+#include <llvm/ADT/SmallString.h>
+#include <llvm/Support/Path.h>
+
+namespace feature_extractor {
+
+bool isWithinProject(const ProjectContext &ctx, llvm::StringRef abs_path) {
+  if (ctx.project_root.empty() || abs_path.empty()) {
+    return false;
+  }
+  llvm::SmallString<256> root(ctx.project_root);
+  llvm::sys::path::remove_dots(root, /*remove_dot_dot=*/true);
+  llvm::SmallString<256> path(abs_path);
+  llvm::sys::path::remove_dots(path, /*remove_dot_dot=*/true);
+  return path.str().starts_with(root.str());
+}
+
+std::string relativeHeaderPath(const ProjectContext &ctx,
+                               llvm::StringRef abs_path) {
+  if (!isWithinProject(ctx, abs_path)) {
+    return std::string(abs_path);
+  }
+  llvm::StringRef rel = abs_path.drop_front(ctx.project_root.size());
+  while (!rel.empty() && rel.front() == '/') {
+    rel = rel.drop_front(1);
+  }
+  return std::string(rel);
+}
+
+void FeatureCollector::addFunction(FunctionInfo info) {
+  if (!seen_functions_.insert(info.signature).second) {
+    return;
+  }
+  artifact_.functions.push_back(std::move(info));
+}
+
+void FeatureCollector::addTypedef(TypedefInfo info) {
+  std::string key = info.name + "|" + info.header_path;
+  if (!seen_typedefs_.insert(key).second) {
+    return;
+  }
+  artifact_.typedefs.push_back(std::move(info));
+}
+
+void FeatureCollector::addMacro(MacroInfo info) {
+  std::string key = info.name + "|" + info.value;
+  if (!seen_macros_.insert(key).second) {
+    return;
+  }
+  artifact_.macros.push_back(std::move(info));
+}
+
+void FeatureCollector::addEnum(EnumInfo info) {
+  std::string key = info.name.value_or("") + "|" + info.header_path;
+  if (!seen_enums_.insert(key).second) {
+    return;
+  }
+  artifact_.enums.push_back(std::move(info));
+}
+
+void FeatureCollector::addRecord(RecordInfo info) {
+  std::string key =
+      info.kind + "|" + info.name.value_or("") + "|" + info.header_path;
+  if (!seen_records_.insert(key).second) {
+    return;
+  }
+  artifact_.records.push_back(std::move(info));
+}
+
+void FeatureCollector::addWarning(std::string warning) {
+  artifact_.warnings.push_back(std::move(warning));
+}
+
+namespace {
+
+bool hasSourceExtension(llvm::StringRef path) {
+  return path.ends_with(".c") || path.ends_with(".cc") ||
+         path.ends_with(".cpp") || path.ends_with(".cxx") ||
+         path.ends_with(".m") || path.ends_with(".mm");
+}
+
+// Public API means external linkage plus a declaration inside a library-owned
+// header — not a system header, and not a .c/.cpp translation unit.
+bool isPublicApiLocation(const clang::NamedDecl &decl,
+                         const ProjectContext &ctx,
+                         const clang::SourceManager &sm) {
+  if (decl.getLinkageInternal() != clang::Linkage::External) {
+    return false;
+  }
+  clang::SourceLocation loc = sm.getSpellingLoc(decl.getLocation());
+  if (loc.isInvalid() || sm.isInSystemHeader(loc)) {
+    return false;
+  }
+  llvm::StringRef filename = sm.getFilename(loc);
+  if (filename.empty() || !isWithinProject(ctx, filename)) {
+    return false;
+  }
+  return !hasSourceExtension(filename);
+}
+
+std::string buildSignature(const FunctionInfo &info) {
+  std::string sig = info.return_type + " " + info.name + "(";
+  for (size_t i = 0; i < info.params.size(); ++i) {
+    if (i > 0) {
+      sig += ", ";
+    }
+    sig += info.params[i].type;
+  }
+  sig += ")";
+  return sig;
+}
+
+class ExtractionVisitor : public clang::RecursiveASTVisitor<ExtractionVisitor> {
+public:
+  ExtractionVisitor(FeatureCollector &collector, const ProjectContext &ctx,
+                    const clang::SourceManager &sm)
+      : collector_(collector), ctx_(ctx), sm_(sm) {}
+
+  bool VisitFunctionDecl(clang::FunctionDecl *decl) {
+    if (decl->isImplicit() || llvm::isa<clang::CXXMethodDecl>(decl)) {
+      return true;
+    }
+    clang::SourceLocation loc = sm_.getSpellingLoc(decl->getLocation());
+    if (loc.isInvalid()) {
+      return true;
+    }
+    llvm::StringRef filename = sm_.getFilename(loc);
+    if (filename.empty() || !isWithinProject(ctx_, filename)) {
+      return true;
+    }
+
+    FunctionInfo info;
+    info.name = decl->getNameAsString();
+    if (info.name.empty()) {
+      return true;
+    }
+    info.return_type = decl->getReturnType().getAsString();
+    for (const clang::ParmVarDecl *param : decl->parameters()) {
+      info.params.push_back(
+          Param{param->getNameAsString(), param->getType().getAsString()});
+    }
+    info.signature = buildSignature(info);
+    info.is_public_api = isPublicApiLocation(*decl, ctx_, sm_);
+    info.header_path = relativeHeaderPath(ctx_, filename);
+    collector_.addFunction(std::move(info));
+    return true;
+  }
+
+  bool VisitTypedefNameDecl(clang::TypedefNameDecl *decl) {
+    if (decl->isImplicit()) {
+      return true;
+    }
+    clang::SourceLocation loc = sm_.getSpellingLoc(decl->getLocation());
+    if (loc.isInvalid()) {
+      return true;
+    }
+    llvm::StringRef filename = sm_.getFilename(loc);
+    if (filename.empty() || !isWithinProject(ctx_, filename)) {
+      return true;
+    }
+    TypedefInfo info;
+    info.name = decl->getNameAsString();
+    info.underlying_type = decl->getUnderlyingType().getAsString();
+    info.header_path = relativeHeaderPath(ctx_, filename);
+    collector_.addTypedef(std::move(info));
+    return true;
+  }
+
+  bool VisitEnumDecl(clang::EnumDecl *decl) {
+    if (!decl->isThisDeclarationADefinition()) {
+      return true;
+    }
+    clang::SourceLocation loc = sm_.getSpellingLoc(decl->getLocation());
+    if (loc.isInvalid()) {
+      return true;
+    }
+    llvm::StringRef filename = sm_.getFilename(loc);
+    if (filename.empty() || !isWithinProject(ctx_, filename)) {
+      return true;
+    }
+    EnumInfo info;
+    if (decl->getIdentifier() != nullptr) {
+      info.name = decl->getNameAsString();
+    }
+    for (const clang::EnumConstantDecl *ecd : decl->enumerators()) {
+      info.enumerators.push_back(
+          Enumerator{ecd->getNameAsString(), ecd->getInitVal().getSExtValue()});
+    }
+    info.header_path = relativeHeaderPath(ctx_, filename);
+    collector_.addEnum(std::move(info));
+    return true;
+  }
+
+  bool VisitRecordDecl(clang::RecordDecl *decl) {
+    if (!decl->isThisDeclarationADefinition() ||
+        (!decl->isStruct() && !decl->isUnion())) {
+      return true;
+    }
+    clang::SourceLocation loc = sm_.getSpellingLoc(decl->getLocation());
+    if (loc.isInvalid()) {
+      return true;
+    }
+    llvm::StringRef filename = sm_.getFilename(loc);
+    if (filename.empty() || !isWithinProject(ctx_, filename)) {
+      return true;
+    }
+    RecordInfo info;
+    if (decl->getIdentifier() != nullptr) {
+      info.name = decl->getNameAsString();
+    }
+    info.kind = decl->isUnion() ? "union" : "struct";
+    for (const clang::FieldDecl *field : decl->fields()) {
+      info.fields.push_back(
+          Field{field->getNameAsString(), field->getType().getAsString()});
+    }
+    info.header_path = relativeHeaderPath(ctx_, filename);
+    collector_.addRecord(std::move(info));
+    return true;
+  }
+
+private:
+  FeatureCollector &collector_;
+  const ProjectContext &ctx_;
+  const clang::SourceManager &sm_;
+};
+
+class ExtractionASTConsumer : public clang::ASTConsumer {
+public:
+  ExtractionASTConsumer(FeatureCollector &collector, ProjectContext ctx)
+      : collector_(collector), ctx_(std::move(ctx)) {}
+
+  void HandleTranslationUnit(clang::ASTContext &context) override {
+    ExtractionVisitor visitor(collector_, ctx_, context.getSourceManager());
+    visitor.TraverseDecl(context.getTranslationUnitDecl());
+  }
+
+private:
+  FeatureCollector &collector_;
+  ProjectContext ctx_;
+};
+
+class ExtractionFrontendAction : public clang::ASTFrontendAction {
+public:
+  ExtractionFrontendAction(FeatureCollector &collector, ProjectContext ctx)
+      : collector_(collector), ctx_(std::move(ctx)) {}
+
+  bool BeginSourceFileAction(clang::CompilerInstance &ci) override {
+    ci.getPreprocessor().addPPCallbacks(newMacroCollectorCallbacks(
+        collector_, ctx_, ci.getSourceManager(), ci.getLangOpts()));
+    return true;
+  }
+
+  std::unique_ptr<clang::ASTConsumer>
+  CreateASTConsumer(clang::CompilerInstance & /*ci*/,
+                    llvm::StringRef /*file*/) override {
+    return std::make_unique<ExtractionASTConsumer>(collector_, ctx_);
+  }
+
+private:
+  FeatureCollector &collector_;
+  ProjectContext ctx_;
+};
+
+class ExtractionFrontendActionFactory
+    : public clang::tooling::FrontendActionFactory {
+public:
+  ExtractionFrontendActionFactory(FeatureCollector &collector,
+                                  ProjectContext ctx)
+      : collector_(collector), ctx_(std::move(ctx)) {}
+
+  std::unique_ptr<clang::FrontendAction> create() override {
+    return std::make_unique<ExtractionFrontendAction>(collector_, ctx_);
+  }
+
+private:
+  FeatureCollector &collector_;
+  ProjectContext ctx_;
+};
+
+} // namespace
+
+std::unique_ptr<clang::tooling::FrontendActionFactory>
+newExtractionActionFactory(FeatureCollector &collector, ProjectContext ctx) {
+  return std::make_unique<ExtractionFrontendActionFactory>(collector,
+                                                           std::move(ctx));
+}
+
+} // namespace feature_extractor

fuzzprep/feature_extractor/native/src/json_writer.cpp

@@ -0,0 +1,154 @@
+#include "feature_extractor.hpp"
+
+#include <cJSON.h>
+
+namespace feature_extractor {
+
+namespace {
+
+cJSON *createParamArray(const std::vector<Param> &params) {
+  cJSON *array = cJSON_CreateArray();
+  for (const auto &param : params) {
+    cJSON *item = cJSON_CreateObject();
+    cJSON_AddStringToObject(item, "name", param.name.c_str());
+    cJSON_AddStringToObject(item, "type", param.type.c_str());
+    cJSON_AddItemToArray(array, item);
+  }
+  return array;
+}
+
+cJSON *createStringArray(const std::vector<std::string> &values) {
+  cJSON *array = cJSON_CreateArray();
+  for (const auto &value : values) {
+    cJSON_AddItemToArray(array, cJSON_CreateString(value.c_str()));
+  }
+  return array;
+}
+
+void addOptionalString(cJSON *object, const char *key,
+                        const std::optional<std::string> &value) {
+  if (value.has_value()) {
+    cJSON_AddStringToObject(object, key, value->c_str());
+  } else {
+    cJSON_AddNullToObject(object, key);
+  }
+}
+
+cJSON *createFunction(const FunctionInfo &fn) {
+  cJSON *object = cJSON_CreateObject();
+  cJSON_AddStringToObject(object, "name", fn.name.c_str());
+  cJSON_AddStringToObject(object, "return_type", fn.return_type.c_str());
+  cJSON_AddItemToObject(object, "params", createParamArray(fn.params));
+  cJSON_AddStringToObject(object, "signature", fn.signature.c_str());
+  cJSON_AddBoolToObject(object, "is_public_api", fn.is_public_api);
+  cJSON_AddStringToObject(object, "header_path", fn.header_path.c_str());
+  return object;
+}
+
+cJSON *createTypedef(const TypedefInfo &td) {
+  cJSON *object = cJSON_CreateObject();
+  cJSON_AddStringToObject(object, "name", td.name.c_str());
+  cJSON_AddStringToObject(object, "underlying_type", td.underlying_type.c_str());
+  cJSON_AddStringToObject(object, "header_path", td.header_path.c_str());
+  return object;
+}
+
+cJSON *createMacro(const MacroInfo &macro) {
+  cJSON *object = cJSON_CreateObject();
+  cJSON_AddStringToObject(object, "name", macro.name.c_str());
+  cJSON_AddBoolToObject(object, "is_function_like", macro.is_function_like);
+  cJSON_AddItemToObject(object, "params", createStringArray(macro.params));
+  cJSON_AddStringToObject(object, "value", macro.value.c_str());
+  cJSON_AddStringToObject(object, "header_path", macro.header_path.c_str());
+  return object;
+}
+
+cJSON *createEnumerator(const Enumerator &e) {
+  cJSON *object = cJSON_CreateObject();
+  cJSON_AddStringToObject(object, "name", e.name.c_str());
+  // cJSON stores numbers as double, so a value beyond +-2^53 loses precision.
+  // Real-world enum constants stay well inside that range.
+  cJSON_AddNumberToObject(object, "value", static_cast<double>(e.value));
+  return object;
+}
+
+cJSON *createEnum(const EnumInfo &e) {
+  cJSON *object = cJSON_CreateObject();
+  addOptionalString(object, "name", e.name);
+  cJSON *enumerators = cJSON_CreateArray();
+  for (const auto &enumerator : e.enumerators) {
+    cJSON_AddItemToArray(enumerators, createEnumerator(enumerator));
+  }
+  cJSON_AddItemToObject(object, "enumerators", enumerators);
+  cJSON_AddStringToObject(object, "header_path", e.header_path.c_str());
+  return object;
+}
+
+cJSON *createField(const Field &field) {
+  cJSON *object = cJSON_CreateObject();
+  cJSON_AddStringToObject(object, "name", field.name.c_str());
+  cJSON_AddStringToObject(object, "type", field.type.c_str());
+  return object;
+}
+
+cJSON *createRecord(const RecordInfo &record) {
+  cJSON *object = cJSON_CreateObject();
+  addOptionalString(object, "name", record.name);
+  cJSON_AddStringToObject(object, "kind", record.kind.c_str());
+  cJSON *fields = cJSON_CreateArray();
+  for (const auto &field : record.fields) {
+    cJSON_AddItemToArray(fields, createField(field));
+  }
+  cJSON_AddItemToObject(object, "fields", fields);
+  cJSON_AddStringToObject(object, "header_path", record.header_path.c_str());
+  return object;
+}
+
+} // namespace
+
+std::string writeJson(const FeatureArtifact &artifact) {
+  cJSON *root = cJSON_CreateObject();
+  cJSON_AddNumberToObject(root, "schema_version", artifact.schema_version);
+  cJSON_AddStringToObject(root, "project_name", artifact.project_name.c_str());
+  cJSON_AddStringToObject(root, "language", artifact.language.c_str());
+
+  cJSON *functions = cJSON_CreateArray();
+  for (const auto &fn : artifact.functions) {
+    cJSON_AddItemToArray(functions, createFunction(fn));
+  }
+  cJSON_AddItemToObject(root, "functions", functions);
+
+  cJSON *typedefs = cJSON_CreateArray();
+  for (const auto &td : artifact.typedefs) {
+    cJSON_AddItemToArray(typedefs, createTypedef(td));
+  }
+  cJSON_AddItemToObject(root, "typedefs", typedefs);
+
+  cJSON *macros = cJSON_CreateArray();
+  for (const auto &macro : artifact.macros) {
+    cJSON_AddItemToArray(macros, createMacro(macro));
+  }
+  cJSON_AddItemToObject(root, "macros", macros);
+
+  cJSON *enums = cJSON_CreateArray();
+  for (const auto &e : artifact.enums) {
+    cJSON_AddItemToArray(enums, createEnum(e));
+  }
+  cJSON_AddItemToObject(root, "enums", enums);
+
+  cJSON *records = cJSON_CreateArray();
+  for (const auto &record : artifact.records) {
+    cJSON_AddItemToArray(records, createRecord(record));
+  }
+  cJSON_AddItemToObject(root, "records", records);
+
+  cJSON_AddItemToObject(root, "warnings", createStringArray(artifact.warnings));
+
+  char *rendered = cJSON_PrintUnformatted(root);
+  std::string result(rendered);
+  cJSON_free(rendered);
+  cJSON_Delete(root);
+  return result;
+}
+
+} // namespace feature_extractor

fuzzprep/feature_extractor/native/src/macro_callbacks.cpp

@@ -0,0 +1,75 @@
+#include "feature_extractor.hpp"
+
+#include <clang/Lex/Lexer.h>
+#include <clang/Lex/MacroInfo.h>
+#include <clang/Lex/Token.h>
+
+namespace feature_extractor {
+
+namespace {
+
+class MacroCollectorCallbacks : public clang::PPCallbacks {
+public:
+  MacroCollectorCallbacks(FeatureCollector &collector, ProjectContext ctx,
+                          const clang::SourceManager &sm,
+                          const clang::LangOptions &lang_opts)
+      : collector_(collector), ctx_(std::move(ctx)), sm_(sm),
+        lang_opts_(lang_opts) {}
+
+  void MacroDefined(const clang::Token &name_tok,
+                    const clang::MacroDirective *md) override {
+    const clang::MacroInfo *mi = md->getMacroInfo();
+    if (mi == nullptr || name_tok.getIdentifierInfo() == nullptr) {
+      return;
+    }
+    clang::SourceLocation loc = sm_.getSpellingLoc(mi->getDefinitionLoc());
+    if (loc.isInvalid() || sm_.isInSystemHeader(loc)) {
+      return;
+    }
+    llvm::StringRef filename = sm_.getFilename(loc);
+    if (filename.empty() || !isWithinProject(ctx_, filename)) {
+      return;
+    }
+
+    MacroInfo info;
+    info.name = name_tok.getIdentifierInfo()->getName().str();
+    info.is_function_like = mi->isFunctionLike();
+    if (info.is_function_like) {
+      for (const clang::IdentifierInfo *param : mi->params()) {
+        info.params.push_back(param->getName().str());
+      }
+    }
+    info.value = macroValueText(*mi);
+    info.header_path = relativeHeaderPath(ctx_, filename);
+    collector_.addMacro(std::move(info));
+  }
+
+private:
+  std::string macroValueText(const clang::MacroInfo &mi) const {
+    std::string value;
+    for (const clang::Token &tok : mi.tokens()) {
+      if (!value.empty()) {
+        value += " ";
+      }
+      value += clang::Lexer::getSpelling(tok, sm_, lang_opts_);
+    }
+    return value;
+  }
+
+  FeatureCollector &collector_;
+  ProjectContext ctx_;
+  const clang::SourceManager &sm_;
+  const clang::LangOptions &lang_opts_;
+};
+
+} // namespace
+
+std::unique_ptr<clang::PPCallbacks>
+newMacroCollectorCallbacks(FeatureCollector &collector, ProjectContext ctx,
+                           const clang::SourceManager &sm,
+                           const clang::LangOptions &lang_opts) {
+  return std::make_unique<MacroCollectorCallbacks>(collector, std::move(ctx),
+                                                   sm, lang_opts);
+}
+
+} // namespace feature_extractor

fuzzprep/feature_extractor/native/src/main.cpp

@@ -0,0 +1,130 @@
+#include "feature_extractor.hpp"
+
+#include <clang/Tooling/CompilationDatabase.h>
+#include <clang/Tooling/Tooling.h>
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/Path.h>
+#include <llvm/Support/raw_ostream.h>
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+namespace {
+
+bool looksLikeCxx(llvm::StringRef path) {
+  return path.ends_with(".cc") || path.ends_with(".cpp") ||
+         path.ends_with(".cxx") || path.ends_with(".hpp") ||
+         path.ends_with(".hh") || path.ends_with(".hxx") ||
+         path.ends_with(".mm");
+}
+
+std::string detectLanguage(const std::vector<std::string> &files) {
+  // Must match models.Language's values ("c" | "c++"), which extraction.py parses.
+  for (const std::string &file : files) {
+    if (looksLikeCxx(file)) {
+      return "c++";
+    }
+  }
+  return "c";
+}
+
+// The compile-commands directory (argv[1]) is often a separate build directory,
+// not the source checkout, so it cannot serve as the project root. Recover the
+// real root as the common ancestor of every translation unit's absolute path.
+std::string computeProjectRoot(const std::vector<std::string> &files) {
+  std::vector<llvm::StringRef> common;
+  bool first = true;
+  for (const std::string &file : files) {
+    llvm::SmallString<256> dir(file);
+    llvm::sys::path::remove_filename(dir);
+    llvm::sys::path::remove_dots(dir, /*remove_dot_dot=*/true);
+    std::vector<llvm::StringRef> components(llvm::sys::path::begin(dir),
+                                             llvm::sys::path::end(dir));
+    if (first) {
+      common = std::move(components);
+      first = false;
+      continue;
+    }
+    size_t limit = std::min(common.size(), components.size());
+    size_t matched = 0;
+    while (matched < limit && common[matched] == components[matched]) {
+      ++matched;
+    }
+    common.resize(matched);
+  }
+  llvm::SmallString<256> root;
+  for (llvm::StringRef component : common) {
+    llvm::sys::path::append(root, component);
+  }
+  return std::string(root);
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+  if (argc != 4) {
+    llvm::errs()
+        << "usage: feature_extractor <compile-commands-dir> <output-json-path> "
+           "<project-name>\n";
+    return 1;
+  }
+
+  llvm::SmallString<256> compile_commands_dir(argv[1]);
+  llvm::sys::fs::make_absolute(compile_commands_dir);
+  llvm::sys::path::remove_dots(compile_commands_dir, /*remove_dot_dot=*/true);
+  const std::string output_json_path = argv[2];
+  const std::string project_name = argv[3];
+
+  std::string error_message;
+  std::unique_ptr<clang::tooling::CompilationDatabase> db =
+      clang::tooling::CompilationDatabase::autoDetectFromDirectory(
+          compile_commands_dir, error_message);
+  if (db == nullptr) {
+    llvm::errs() << "error loading compile_commands.json from "
+                 << compile_commands_dir << ": " << error_message << "\n";
+    return 1;
+  }
+
+  std::vector<std::string> files = db->getAllFiles();
+  feature_extractor::FeatureCollector collector;
+  feature_extractor::ProjectContext ctx{computeProjectRoot(files)};
+
+  clang::tooling::ClangTool tool(*db, files);
+  tool.appendArgumentsAdjuster(clang::tooling::getInsertArgumentAdjuster(
+      "-resource-dir=" CLANG_RESOURCE_DIR,
+      clang::tooling::ArgumentInsertPosition::BEGIN));
+  // -resource-dir covers only clang's builtin headers (stddef.h, stdarg.h, ...).
+  // Platform libc headers still need an explicit -isysroot on macOS, since
+  // ClangTool's ad hoc driver invocation does not auto-detect the Xcode SDK the way
+  // a plain `clang` does. CLANG_SYSROOT is empty elsewhere, where the default
+  // system include paths apply.
+  const std::string clang_sysroot = CLANG_SYSROOT;
+  if (!clang_sysroot.empty()) {
+    tool.appendArgumentsAdjuster(clang::tooling::getInsertArgumentAdjuster(
+        {"-isysroot", clang_sysroot},
+        clang::tooling::ArgumentInsertPosition::BEGIN));
+  }
+  std::unique_ptr<clang::tooling::FrontendActionFactory> factory =
+      feature_extractor::newExtractionActionFactory(collector, ctx);
+  int run_result = tool.run(factory.get());
+
+  feature_extractor::FeatureArtifact artifact = collector.artifact();
+  artifact.project_name = project_name;
+  artifact.language = detectLanguage(files);
+  if (run_result != 0) {
+    artifact.warnings.push_back(
+        "one or more translation units in compile_commands.json failed to "
+        "compile "
+        "cleanly; extraction may be incomplete for those files");
+  }
+
+  std::ofstream out(output_json_path);
+  if (!out) {
+    llvm::errs() << "error: could not open " << output_json_path
+                 << " for writing\n";
+    return 1;
+  }
+  out << feature_extractor::writeJson(artifact);
+  return 0;
+}