Swift: Extract files

Author: AlexDenisov

swift/extractor/BUILD.bazel

@@ -8,7 +8,15 @@ alias(
 
 cc_binary(
     name = "extractor",
-    srcs = ["main.cpp"],
+    srcs = [
+        "Extractor.h",
+        "Extractor.cpp",
+        "Configuration.h",
+        "main.cpp",
+    ],
+    copts = [
+        "-fno-rtti",
+    ],
     target_compatible_with = select({
         "@platforms//os:linux": [],
         "@platforms//os:macos": [],

swift/extractor/Configuration.h

@@ -0,0 +1,15 @@
+#ifndef SWIFT_EXTRACTOR_CONFIGURATION_H_
+#define SWIFT_EXTRACTOR_CONFIGURATION_H_
+
+#include <string>
+#include <vector>
+
+namespace codeql {
+struct Configuration {
+  std::string trapDir;
+  std::string sourceArchiveDir;
+  std::vector<const char*> frontendOptions;
+};
+}  // namespace codeql
+
+#endif  // SWIFT_EXTRACTOR_CONFIGURATION_H_

swift/extractor/Extractor.cpp

@@ -0,0 +1,101 @@
+#include "Extractor.h"
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <memory>
+#include <unistd.h>
+
+#include <swift/AST/SourceFile.h>
+#include <llvm/ADT/SmallString.h>
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/Path.h>
+
+using namespace codeql;
+
+Extractor::Extractor(const Configuration& config, swift::CompilerInstance& instance)
+    : config{config}, compiler{instance} {}
+
+void Extractor::extract() {
+  if (compiler.getPrimarySourceFiles().empty()) {
+    swift::ModuleDecl* module = compiler.getMainModule();
+    if (!module->getFiles().empty() &&
+        module->getFiles().front()->getKind() == swift::FileUnitKind::Source) {
+      /// We can only call getMainSourceFile if the first file is of a Source kind
+      swift::SourceFile& file = module->getMainSourceFile();
+      extractFile(file);
+    }
+  } else {
+    for (auto s : compiler.getPrimarySourceFiles()) {
+      extractFile(*s);
+    }
+  }
+}
+
+void Extractor::extractFile(swift::SourceFile& file) {
+  if (std::error_code ec = llvm::sys::fs::create_directories(config.trapDir)) {
+    std::cerr << "Cannot create TRAP directory: " << ec.message() << "\n";
+    return;
+  }
+
+  if (std::error_code ec = llvm::sys::fs::create_directories(config.sourceArchiveDir)) {
+    std::cerr << "Cannot create source archive directory: " << ec.message() << "\n";
+    return;
+  }
+
+  llvm::SmallString<PATH_MAX> srcFilePath(file.getFilename());
+  llvm::sys::fs::make_absolute(srcFilePath);
+
+  llvm::SmallString<PATH_MAX> dstFilePath(config.sourceArchiveDir);
+  llvm::sys::path::append(dstFilePath, srcFilePath);
+
+  llvm::StringRef parent = llvm::sys::path::parent_path(dstFilePath);
+  if (std::error_code ec = llvm::sys::fs::create_directories(parent)) {
+    std::cerr << "Cannot create source archive destination directory '" << parent.str()
+              << "': " << ec.message() << "\n";
+    return;
+  }
+
+  if (std::error_code ec = llvm::sys::fs::copy_file(srcFilePath, dstFilePath)) {
+    std::cerr << "Cannot archive source file '" << srcFilePath.str().str() << "' -> '"
+              << dstFilePath.str().str() << "': " << ec.message() << "\n";
+    return;
+  }
+
+  /// TODO: find a more robust approach to avoid collisions?
+  std::string tempTrapName = file.getFilename().str() + '.' + std::to_string(getpid()) + ".trap";
+  llvm::SmallString<PATH_MAX> tempTrapPath(config.trapDir);
+  llvm::sys::path::append(tempTrapPath, tempTrapName);
+
+  std::ofstream trap(tempTrapPath.str().str());
+  if (!trap) {
+    std::error_code ec;
+    ec.assign(errno, std::generic_category());
+    std::cerr << "Cannot create temp trap file '" << tempTrapPath.str().str()
+              << "': " << ec.message() << "\n";
+    return;
+  }
+  std::stringstream ss;
+  ss << "-frontend ";
+  for (auto opt : config.frontendOptions) {
+    ss << std::quoted(opt) << " ";
+  }
+  ss << "\n";
+  trap << "// frontend-options: " << ss.str();
+
+  trap << "#0=*\n";
+  trap << "files(#0, " << std::quoted(srcFilePath.str().str()) << ")\n";
+
+  /// TODO: Pick a better name to avoid collisions
+  std::string trapName = file.getFilename().str() + ".trap";
+  llvm::SmallString<PATH_MAX> trapPath(config.trapDir);
+  llvm::sys::path::append(trapPath, trapName);
+
+  /// TODO: The last process wins. Should we do better than that?
+  if (std::error_code ec = llvm::sys::fs::rename(tempTrapPath, trapPath)) {
+    std::cerr << "Cannot rename temp trap file '" << tempTrapPath.str().str() << "' -> '"
+              << trapPath.str().str() << "': " << ec.message() << "\n";
+  }
+}
+

swift/extractor/Extractor.h

@@ -0,0 +1,24 @@
+#ifndef SWIFT_EXTRACTOR_H_
+#define SWIFT_EXTRACTOR_H_
+
+#include "Configuration.h"
+#include <swift/AST/SourceFile.h>
+#include <swift/Frontend/Frontend.h>
+#include <memory>
+
+namespace codeql {
+
+class Extractor {
+ public:
+  explicit Extractor(const Configuration& config, swift::CompilerInstance& instance);
+  void extract();
+
+ private:
+  void extractFile(swift::SourceFile& file);
+
+  const Configuration& config;
+  swift::CompilerInstance& compiler;
+};
+}  // namespace codeql
+
+#endif  // SWIFT_EXTRACTOR_H_

swift/extractor/main.cpp

@@ -3,15 +3,58 @@
 #include <stdlib.h>
 
 #include <swift/Basic/LLVMInitialize.h>
+#include <swift/FrontendTool/FrontendTool.h>
+
+#include "Extractor.h"
+
+using namespace std::string_literals;
+
+class Observer : public swift::FrontendObserver {
+ public:
+  explicit Observer(const codeql::Configuration& config) : config{config} {}
+
+  void performedSemanticAnalysis(swift::CompilerInstance& instance) override {
+    codeql::Extractor extractor{config, instance};
+    extractor.extract();
+  }
+
+ private:
+  const codeql::Configuration& config;
+};
+
+static std::string getenv_default(const char* envvar, const std::string& def) {
+  if (const char* var = getenv(envvar)) {
+    return var;
+  }
+  return def;
+}
 
 int main(int argc, char** argv) {
+  if (argc == 1) {
+    /// TODO: print usage
+    return 1;
+  }
+  /// The frontend can be called in different modes, we are only interested
+  /// in -frontend mode
+  /// TODO: filter out at the tracer level
+  if ("-frontend"s != argv[1]) {
+    return 0;
+  }
   PROGRAM_START(argc, argv);
-  if (auto trapDir = getenv("CODEQL_EXTRACTOR_SWIFT_TRAP_DIR")) {
-    std::string file = trapDir;
-    file += "/my_first.trap";
-    if (std::ofstream out{file}) {
-      out << "answer_to_life_the_universe_and_everything(42)\n";
+
+  codeql::Configuration configuration{};
+  configuration.trapDir = getenv_default("CODEQL_EXTRACTOR_SWIFT_TRAP_DIR", ".");
+  configuration.sourceArchiveDir = getenv_default("CODEQL_EXTRACTOR_SWIFT_SOURCE_ARCHIVE_DIR", ".");
+  std::vector<const char*> args;
+  for (int i = 1; i < argc; i++) {
+    if ("-frontend"s == argv[i]) {
+      continue;
     }
+    args.push_back(argv[i]);
   }
-  return 0;
+  configuration.frontendOptions = args;
+  Observer observer(configuration);
+  int frontend_rc = swift::performFrontend(args, "swift-extractor", (void*)main, &observer);
+  llvm::llvm_shutdown();
+  return frontend_rc;
 }

swift/ql/lib/swift.qll

@@ -0,0 +1,3 @@
+/** Top-level import for the Swift language pack */
+
+import swift.File

swift/ql/lib/swift/File.qll

@@ -0,0 +1,24 @@
+/** TODO: to be replaced */
+
+/** A file. */
+class File extends @file {
+  /** toString */
+  string toString() { result = getAbsolutePath() }
+
+  /** Gets the name of this file. */
+  string getName() { files(this, result) }
+
+  /** Gets the absolute path of this file. */
+  string getAbsolutePath() { result = getName() }
+
+  /** Gets the full name of this file. */
+  string getFullName() { result = getAbsolutePath() }
+
+  /** Gets the URL of this file. */
+  string getURL() { result = "file://" + this.getAbsolutePath() + ":0:0:0:0" }
+
+  /** Gets the base name of this file. */
+  string getBaseName() {
+    result = this.getAbsolutePath().regexpCapture(".*/(([^/]*?)(?:\\.([^.]*))?)", 1)
+  }
+}

swift/ql/test/answer.expected

@@ -0,0 +1 @@
+| hello.swift:0:0:0:0 | hello.swift |