test(aot): adds bash test suite for ahead of time compilation

Author: Samy-33

compiler+runtime/include/cpp/jank/util/cli.hpp

@@ -54,12 +54,6 @@ namespace jank::util::cli
     command command{ command::repl };
   };
 
-  struct empty_options
-  {
-    /* TODO: Use a native_persistent_vector instead. */
-    std::vector<native_transient_string> opts;
-  };
-
   jtl::result<options, int> parse(int const argc, char const **argv);
-  empty_options parse_empty(int const argc, char const **argv);
+  std::vector<native_transient_string> parse_empty(int const argc, char const **argv);
 }

compiler+runtime/src/cpp/jank/aot/processor.cpp

@@ -169,8 +169,26 @@ int main(int argc, const char** argv)
 
     for(auto const &module : __rt_ctx->loaded_modules_in_order)
     {
-      auto const &module_path{ module::module_to_path(module) };
-      Args.push_back(strdup(util::format("{}.o", relative_to_cache_dir(module_path)).c_str()));
+      auto const &module_path{
+        util::format("{}.o", relative_to_cache_dir(module::module_to_path(module)))
+      };
+
+      if(std::filesystem::exists(module_path.c_str()))
+      {
+        Args.push_back(strdup(module_path.c_str()));
+      }
+      else
+      {
+        auto const find_res{ __rt_ctx->module_loader.find(module, module::origin::latest) };
+        if(find_res.is_ok() && find_res.expect_ok().sources.o.is_some())
+        {
+          Args.push_back(strdup(find_res.expect_ok().sources.o.unwrap().path.c_str()));
+        }
+        else
+        {
+          return compiler_err{ 1, util::format("module '{}' not found", module) };
+        }
+      }
     }
 
     Args.push_back(strdup("-x"));

compiler+runtime/src/cpp/jank/c_api.cpp

@@ -999,9 +999,9 @@ extern "C"
   jank_object_ref jank_parse_command_line_args(int const argc, char const **argv)
   {
     obj::transient_vector trans;
-    auto const opts{ util::cli::parse_empty(argc, argv).opts };
+    auto const args{ util::cli::parse_empty(argc, argv) };
 
-    for(auto &arg : opts)
+    for(auto const &arg : args)
     {
       trans.conj_in_place(make_box(arg));
     }

compiler+runtime/src/cpp/jank/util/cli.cpp

@@ -132,19 +132,12 @@ namespace jank::util::cli
     return ok(opts);
   }
 
-  empty_options parse_empty(int const argc, char const **argv)
+  std::vector<native_transient_string> parse_empty(int const argc, char const **argv)
   {
     CLI::App cli{ "jank default cli" };
-    empty_options opts;
     cli.allow_extras();
-
     cli.parse(argc, argv);
 
-    if(cli.remaining_size() > 0)
-    {
-      opts.opts = cli.remaining();
-    }
-
-    return opts;
+    return cli.remaining();
   }
 }

compiler+runtime/test/bash/ahead-of-time/deps.edn

@@ -0,0 +1,4 @@
+{:paths ["src/common"]
+ :aliases {:single-jank-module {:extra-paths ["src/single-jank-module"]}
+           :only-jank-modules {:extra-paths ["src/only-jank-modules"]}
+           :jank-and-cpp-modules {:extra-paths ["src/jank-and-cpp-modules"]}}}

compiler+runtime/test/bash/ahead-of-time/expected_outputs/jank-and-cpp-modules/core

@@ -0,0 +1,6 @@
+Loaded 'my-lib
+Loaded 'lib
+Loaded 'core
+Received args: (foo bar)
+Hello, foo!
+Hello from cpp module, bar!

compiler+runtime/test/bash/ahead-of-time/expected_outputs/only-jank-modules/core

@@ -0,0 +1,7 @@
+Loaded 'lib
+Loaded 'app
+Loaded 'core
+Hello, Admin!
+Running app on port: 3000
+Bow Bow, Admin please!
+Done running the app!

compiler+runtime/test/bash/ahead-of-time/expected_outputs/single-jank-module/main-with-args

@@ -0,0 +1 @@
+Received args: (foo bar baz)

compiler+runtime/test/bash/ahead-of-time/expected_outputs/single-jank-module/main-without-args

@@ -0,0 +1 @@
+No args

compiler+runtime/test/bash/ahead-of-time/pass-test

@@ -0,0 +1,117 @@
+#!/usr/bin/env bb
+
+(ns jank.test.ahead-of-time
+  (:require
+   [babashka.fs :as fs]
+   [babashka.process :as proc]
+   [clojure.string :as str]
+   [clojure.test :as t :refer [deftest is run-test testing use-fixtures]]))
+
+(def this-nsym (ns-name *ns*))
+
+(def jank-path
+  (-> (proc/sh "which jank") :out str/trim))
+
+(def jank-build-dir (fs/parent jank-path))
+
+(def lib-paths
+  ;; TODO: These library paths should ideally be included
+  ;; in the AOT program
+  (let [libs-relative-paths ["/" "/third-party/libzippp"
+                             "/third-party/ftxui"
+                             "/third-party/cpptrace"]]
+    (->> libs-relative-paths
+         (map (fn [lib] (str "-L" jank-build-dir lib)))
+         (str/join " "))))
+
+(def jank_exe
+  (str jank-path " -DIMMER_HAS_LIBGC " lib-paths))
+
+(defn- module-path [alias]
+  (-> (proc/sh "clojure" (str "-A:" alias) "-Spath") :out str/trim))
+
+(defn- find-cli []
+  (-> (proc/sh "find ./target -name cli") :out str/trim))
+
+(defn- get-headers []
+  ;; TODO: These headers should be included by default in the AOT program
+  ;; As of now, we expect the users to include these
+  (->> (fs/list-dirs [(str jank-build-dir "/../include")
+                      (str jank-build-dir "/../third-party")
+                      (str jank-build-dir "/third-party")]
+                     (constantly true))
+       (concat ["/usr/lib/clang/19/include" (str jank-build-dir "/../third-party/bpptree/include")])
+       (map #(str "--include-dir " %))
+       (str/join " ")))
+
+(defn compile-command [module-path main-module & {:keys [include-headers?]}]
+  (str jank_exe " --module-path=" module-path
+       " "
+       (when include-headers? (get-headers))
+       " compile " main-module " -o cli"))
+
+(use-fixtures
+  :each
+  (fn [f]
+    (fs/delete-tree "./target")
+    (println "Cleaned up 'target'")
+    (f)))
+
+(deftest aot-only-jank-modules
+  (let [alias-name  "single-jank-module"
+        module-path (module-path alias-name)]
+    (doseq [main-with-args? [true false]
+            :let [main-module (if main-with-args?
+                                "main-with-args"
+                                "main-without-args")
+                  args (if main-with-args?
+                         " foo bar baz"
+                         nil)
+                  expected-output (slurp (str "expected_outputs/" alias-name "/" main-module))
+                  compile-command (compile-command module-path main-module)
+                  cli-path (delay (find-cli))]]
+      (testing (str alias-name " & " main-module)
+        (is (= 0 (-> compile-command proc/sh :exit)))
+        (is (= expected-output (-> @cli-path (str args)
+                                   proc/sh :out))))
+      (testing "Executable in temp directory"
+        (fs/with-temp-dir [dir {}]
+          (fs/move @cli-path dir)
+          (is (= expected-output (->> (str "./cli " args)
+                                      (proc/sh {:dir dir})
+                                      :out))))))))
+
+(deftest aot-multiple-jank-modules
+  (let [alias-name "only-jank-modules"
+        module-path (module-path alias-name)
+        module "core"
+        args " Admin 3000"
+        expected-output (slurp (str "expected_outputs/" alias-name "/" module))
+        compile-command (compile-command module-path module)
+        cli-path (delay (find-cli))]
+    (testing (str alias-name " & core")
+      (is (= 0 (-> compile-command proc/sh :exit)))
+      (is (= expected-output (-> @cli-path (str args)
+                                 proc/sh :out))))))
+
+(deftest aot-jank-and-cpp-modules
+  (let [alias-name "jank-and-cpp-modules"
+        module-path (module-path alias-name)
+        module "core"
+        args " foo bar"
+        expected-output (slurp (str "expected_outputs/" alias-name "/" module))
+        compile-command (compile-command module-path module :include-headers? true)
+        cli-path (delay (find-cli))]
+    (testing (str alias-name " & core")
+      (is (= 0 (-> compile-command proc/sh :exit)))
+      (is (= expected-output (-> @cli-path (str args)
+                                 proc/sh :out))))))
+
+(defn -main []
+  (System/exit
+   (if (t/successful? (t/run-tests this-nsym))
+     0
+     1)))
+
+(when (= *file* (System/getProperty "babashka.file"))
+  (apply -main *command-line-args*))

compiler+runtime/test/bash/ahead-of-time/src/common/app.jank

@@ -0,0 +1,8 @@
+(ns app (:require [lib]))
+
+(defn run [admin port]
+  (println "Running app on port:" port)
+  (lib/bark admin true)
+  (println "Done running the app!"))
+
+(println "Loaded 'app")

compiler+runtime/test/bash/ahead-of-time/src/common/lib.jank

@@ -0,0 +1,9 @@
+(ns lib)
+
+(defn greet [name]
+  (println (str "Hello, " name "!")))
+
+(defn bark [name please?]
+  (println (str "Bow Bow, " name (when please? " please!"))))
+
+(println "Loaded 'lib")

compiler+runtime/test/bash/ahead-of-time/src/jank-and-cpp-modules/core.jank

@@ -0,0 +1,9 @@
+(ns core
+  (:require [my-lib] [lib]))
+
+(defn -main [& args]
+  (println "Received args:" args)
+  (lib/greet (first args))
+  (println (my-lib/greet-str (second args))))
+
+(println "Loaded 'core")

compiler+runtime/test/bash/ahead-of-time/src/jank-and-cpp-modules/my_lib.cpp

@@ -0,0 +1,46 @@
+#include <jtl/immutable_string.hpp>
+
+#include <clojure/core_native.hpp>
+
+#include <jank/runtime/context.hpp>
+#include <jank/runtime/convert/function.hpp>
+#include <jank/runtime/core.hpp>
+#include <jank/runtime/core/equal.hpp>
+#include <jank/runtime/core/meta.hpp>
+#include <jank/runtime/behavior/callable.hpp>
+#include <jank/runtime/visit.hpp>
+#include <jank/util/fmt.hpp>
+
+using jank_object_ref = void *;
+
+using namespace jank;
+using namespace jank::runtime;
+
+static object_ref greet_str(object_ref name)
+{
+  auto const s_obj(try_object<obj::persistent_string>(name));
+  auto const new_str{ "Hello from cpp module, " + s_obj->to_string() + "!"};
+  return make_box(new_str).erase();
+}
+
+extern "C" jank_object_ref jank_load_my_lib()
+{
+  auto const ns_name{ "my-lib" };
+  auto const ns(__rt_ctx->intern_ns(ns_name));
+  __rt_ctx->current_ns_var->set(ns).expect_ok();
+
+
+  auto const intern_fn([=](jtl::immutable_string const &name, auto const fn) {
+    ns->intern_var(name)->bind_root(
+      make_box<obj::native_function_wrapper>(convert_function(fn))
+        ->with_meta(obj::persistent_hash_map::create_unique(std::make_pair(
+          __rt_ctx->intern_keyword("name").expect_ok(),
+          make_box(obj::symbol{ __rt_ctx->current_ns()->to_string(), name }.to_string())))));
+  });
+
+  intern_fn("greet-str", &greet_str);
+
+  __rt_ctx->module_loader.set_is_loaded(ns_name);
+  std::cout<<"Loaded '"<<ns_name<<"\n";
+  return jank_nil.erase();
+}

compiler+runtime/test/bash/ahead-of-time/src/only-jank-modules/core.jank

@@ -0,0 +1,11 @@
+(ns core
+  (:require [app] [lib]))
+
+(defn -main [& [admin port]]
+  (if (or admin port)
+    (do
+      (lib/greet admin)
+      (app/run admin port))
+    (println :failed)))
+
+(println "Loaded 'core")

compiler+runtime/test/bash/ahead-of-time/src/single-jank-module/main_with_args.jank

@@ -0,0 +1,4 @@
+(ns main-with-args)
+
+(defn -main [& args]
+  (println "Received args:" args))

compiler+runtime/test/bash/ahead-of-time/src/single-jank-module/main_without_args.jank

@@ -0,0 +1,4 @@
+(ns main-without-args)
+
+(defn -main []
+  (println "No args"))