Catch type2

.github/workflows/build.yml

@@ -97,10 +97,11 @@ jobs:
             analyze: on
 
           ## Debug + sanitization
-          - name: Ubuntu - address sanitizer
-            os: ubuntu-24.04
-            build_type: Debug
-            sanitize: address
+          # TODO: Fix this. GC issue: https://github.com/bdwgc/bdwgc/issues/772
+          #- name: Ubuntu - address sanitizer
+          #  os: ubuntu-24.04
+          #  build_type: Debug
+          #  sanitize: address
 
           - name: Ubuntu - undefined behavior sanitizer
             os: ubuntu-24.04

.gitignore

@@ -6,7 +6,6 @@ a.out
 .jank-repl-history
 .envrc
 .direnv
-/notes
 
 # Vim files
 /.ycm_extra_conf.py*

.gitmodules

@@ -1,9 +1,6 @@
 [submodule "compiler+runtime/third-party/folly"]
 	path = compiler+runtime/third-party/folly
 	url = https://github.com/jank-lang/folly.git
-[submodule "compiler+runtime/third-party/bpptree"]
-	path = compiler+runtime/third-party/bpptree
-	url = https://github.com/jank-lang/BppTree.git
 [submodule "compiler+runtime/third-party/immer"]
 	path = compiler+runtime/third-party/immer
 	url = https://github.com/jank-lang/immer.git

compiler+runtime/CMakeLists.txt

@@ -42,6 +42,7 @@ option(jank_coverage "Enable code coverage measurement" OFF)
 option(jank_analyze "Enable static analysis" OFF)
 option(jank_test "Enable jank's test suite" OFF)
 option(jank_unity_build "Optimize translation unit compilation for the number of cores" OFF)
+option(jank_debug_gc "Enable GC debug assertions" OFF)
 set(jank_sanitize "none" CACHE STRING "The type of Clang sanitization to use (or none)")
 set(jank_resource_dir
   "../lib/jank/${CMAKE_PROJECT_VERSION}"
@@ -569,7 +570,6 @@ target_include_directories(
   PUBLIC
   "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third-party/nanobench/include>"
   "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third-party/folly>"
-  "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third-party/bpptree/include>"
   "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third-party/bdwgc/include>"
   "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third-party/immer>"
   "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third-party/cli11/include>"
@@ -905,7 +905,7 @@ add_custom_command(
   DEPENDS ${CMAKE_BINARY_DIR}/jank-phase-1 ${CMAKE_SOURCE_DIR}/src/jank/clojure/core.jank ${jank_incremental_pch_flag}
   OUTPUT ${jank_core_libraries_flag}
   BYPRODUCTS ${jank_clojure_core_o}
-  COMMAND ${CMAKE_BINARY_DIR}/jank-phase-1 compile-module -o ${jank_clojure_core_o} clojure.core
+  COMMAND ${CMAKE_BINARY_DIR}/jank-phase-1 compile-module -O3 -o ${jank_clojure_core_o} clojure.core
   COMMAND touch ${jank_core_libraries_flag}
 )
 add_custom_target(

compiler+runtime/cmake/dependency/bdwgc.cmake

@@ -4,18 +4,37 @@ set(BUILD_SHARED_LIBS_OLD ${BUILD_SHARED_LIBS})
 set(CMAKE_CXX_CLANG_TIDY_OLD ${CMAKE_CXX_CLANG_TIDY})
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w")
+
+  if(NOT APPLE)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DREDIRECT_MALLOC=GC_malloc_uncollectable -DREDIR_MALLOC_AND_LINUX_THREADS")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DREDIRECT_MALLOC=GC_malloc_uncollectable -DREDIR_MALLOC_AND_LINUX_THREADS")
+  endif()
+
   set(BUILD_SHARED_LIBS OFF)
   set(CMAKE_CXX_CLANG_TIDY "")
   set(enable_cplusplus ON CACHE BOOL "Enable C++")
   set(build_cord OFF CACHE BOOL "Build cord")
   set(enable_docs OFF CACHE BOOL "Enable docs")
+  set(enable_threads ON CACHE BOOL "Enable multi-threading support")
   set(enable_large_config ON CACHE BOOL "Optimize for large heap or root set")
   set(enable_throw_bad_alloc_library ON CACHE BOOL "Enable C++ gctba library build")
+  set(enable_gc_debug OFF CACHE BOOL "Support for pointer back-tracing")
+
+  if(jank_debug_gc)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DGC_ASSERTIONS")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGC_ASSERTIONS")
+    set(enable_gc_debug ON CACHE BOOL "Support for pointer back-tracing")
+  endif()
+
   add_subdirectory(third-party/bdwgc EXCLUDE_FROM_ALL)
 
   unset(enable_cplusplus)
   unset(build_cord)
   unset(enable_docs)
+  unset(enable_threads)
+  unset(enable_large_config)
+  unset(enable_throw_bad_alloc_library)
+  unset(enable_gc_debug)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_OLD}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_OLD}")
 set(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS_OLD})

compiler+runtime/cmake/install.cmake

@@ -61,11 +61,6 @@ jank_glob_install_without_prefix(
   PATTERN "${CMAKE_SOURCE_DIR}/third-party/folly/folly/*.h"
 )
 
-jank_glob_install_without_prefix(
-  INPUT_PREFIX "${CMAKE_SOURCE_DIR}/third-party/bpptree/"
-  PATTERN "${CMAKE_SOURCE_DIR}/third-party/bpptree/include/*"
-)
-
 jank_glob_install_without_prefix(
   INPUT_PREFIX "${CMAKE_SOURCE_DIR}/third-party/immer/"
   OUTPUT_PREFIX "include/"
@@ -82,12 +77,6 @@ jank_glob_install_without_prefix(
   PATTERN "${CMAKE_SOURCE_DIR}/third-party/ftxui/include/*"
 )
 
-jank_glob_install_without_prefix(
-  INPUT_PREFIX "${CMAKE_SOURCE_DIR}/third-party/libzippp/src/"
-  OUTPUT_PREFIX "include/"
-  PATTERN "${CMAKE_SOURCE_DIR}/third-party/libzippp/src/*"
-)
-
 jank_glob_install_without_prefix(
   INPUT_PREFIX "${CMAKE_SOURCE_DIR}/third-party/cpptrace/"
   PATTERN "${CMAKE_SOURCE_DIR}/third-party/cpptrace/include/*"

compiler+runtime/cmake/summary.cmake

@@ -11,6 +11,7 @@ jank_message("│ jank analyze       : ${jank_analyze}")
 jank_message("│ jank sanitize      : ${jank_sanitize}")
 jank_message("│ jank unity build   : ${jank_unity_build}")
 jank_message("│ jank resource dir  : ${jank_resource_dir}")
+jank_message("│ jank debug gc      : ${jank_debug_gc}")
 jank_message("│ clang version      : ${LLVM_PACKAGE_VERSION}")
 jank_message("│ clang prefix       : ${CLANG_INSTALL_PREFIX}")
 jank_message("│ clang resource dir : ${clang_resource_dir}")

compiler+runtime/include/cpp/jank/analyze/cpp_util.hpp

@@ -28,6 +28,7 @@ namespace jank::analyze::cpp_util
   native_vector<jtl::ptr<void>> find_adl_scopes(native_vector<jtl::ptr<void>> const &starters);
 
   jtl::immutable_string get_qualified_name(jtl::ptr<void> scope);
+  jtl::immutable_string get_qualified_type_name(jtl::ptr<void> type);
   void register_rtti(jtl::ptr<void> type);
 
   jtl::ptr<void> expression_type(expression_ref expr);

compiler+runtime/include/cpp/jank/analyze/expr/if.hpp

@@ -25,6 +25,7 @@ namespace jank::analyze::expr
 
     /* TODO: Rename to have _expr suffixes. */
     expression_ref condition;
+    /* The then/else exprs are expected to have the same type. We handle this during analysis. */
     expression_ref then;
     jtl::option<expression_ref> else_;
   };

compiler+runtime/include/cpp/jank/analyze/expr/try.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
+
 #include <jtl/option.hpp>
 
+#include <jank/analyze/expr/cpp_type.hpp>
 #include <jank/analyze/expression.hpp>
 
 namespace jank::runtime::obj
@@ -36,7 +38,7 @@ namespace jank::analyze::expr
     void walk(std::function<void(jtl::ref<expression>)> const &f) override;
 
     do_ref body;
-    jtl::option<catch_> catch_body{};
+    native_vector<catch_> catch_bodies{};
     jtl::option<do_ref> finally_body{};
   };
 }

compiler+runtime/include/cpp/jank/analyze/expr/var_ref.hpp

@@ -26,6 +26,12 @@ namespace jank::analyze::expr
 
     runtime::object_ref to_runtime_data() const override;
 
+    /* Holds the fully qualified name for the originally resolved var.
+     * It will be useful to know that the var ref happened through a
+     * referred var, for static analysis and error reporting.
+     *
+     * For all the other purposes, `var` member should be used that points
+     * to the actual value of the var.. */
     runtime::obj::symbol_ref qualified_name{};
     runtime::var_ref var{};
   };

compiler+runtime/include/cpp/jank/analyze/local_frame.hpp

@@ -8,6 +8,7 @@
 namespace jank::runtime
 {
   struct context;
+  using var_ref = oref<struct var>;
 
   namespace obj
   {
@@ -29,25 +30,6 @@ namespace jank::analyze
     using function_context_ref = jtl::ref<struct function_context>;
   }
 
-  struct lifted_var
-  {
-    jtl::immutable_string native_name{};
-    runtime::obj::symbol_ref var_name{};
-
-    runtime::object_ref to_runtime_data() const;
-  };
-
-  /* TODO: Track constant usages to figure out if boxing is needed at all,
-   * rather than just doing both. */
-  struct lifted_constant
-  {
-    jtl::immutable_string native_name{};
-    jtl::option<jtl::immutable_string> unboxed_native_name{};
-    runtime::object_ref data{};
-
-    runtime::object_ref to_runtime_data() const;
-  };
-
   struct local_binding
   {
     runtime::obj::symbol_ref name{};
@@ -135,14 +117,6 @@ namespace jank::analyze
 
     static bool within_same_fn(jtl::ptr<local_frame>, jtl::ptr<local_frame>);
 
-    runtime::obj::symbol_ref lift_var(runtime::obj::symbol_ref const &);
-    jtl::option<std::reference_wrapper<lifted_var const>>
-    find_lifted_var(runtime::obj::symbol_ref const &) const;
-
-    void lift_constant(runtime::object_ref);
-    jtl::option<std::reference_wrapper<lifted_constant const>>
-      find_lifted_constant(runtime::object_ref) const;
-
     static local_frame const &find_closest_fn_frame(local_frame const &frame);
     static local_frame &find_closest_fn_frame(local_frame &frame);
 
@@ -152,12 +126,6 @@ namespace jank::analyze
     jtl::option<jtl::ptr<local_frame>> parent;
     native_unordered_map<runtime::obj::symbol_ref, local_binding> locals;
     native_unordered_map<runtime::obj::symbol_ref, local_binding> captures;
-    native_unordered_map<runtime::obj::symbol_ref, lifted_var> lifted_vars;
-    native_unordered_map<runtime::object_ref,
-                         lifted_constant,
-                         std::hash<runtime::object_ref>,
-                         runtime::very_equal_to>
-      lifted_constants;
     /* This is only set if the frame type is fn. */
     jtl::ptr<expr::function_context> fn_ctx;
   };

compiler+runtime/include/cpp/jank/c_api.h

@@ -49,6 +49,8 @@ extern "C"
   jank_object_ref jank_read_string(jank_object_ref s);
   jank_object_ref jank_read_string_c(char const * const s);
 
+  jank_object_ref jank_ns_intern(jank_object_ref sym);
+  jank_object_ref jank_ns_intern_c(char const * const sym);
   void jank_ns_set_symbol_counter(char const * const ns, jank_u64 const count);
 
   jank_object_ref jank_var_intern(jank_object_ref ns, jank_object_ref name);

compiler+runtime/include/cpp/jank/codegen/llvm_processor.hpp

@@ -108,9 +108,10 @@ namespace jank::codegen
     llvm_processor(analyze::expr::function_ref const expr,
                    jtl::immutable_string const &module,
                    compilation_target target);
+    llvm_processor(analyze::expr::function_ref expr, std::unique_ptr<reusable_context> ctx);
     /* For this ctor, we're inheriting the context from another function, which means
      * we're building a nested function. */
-    llvm_processor(analyze::expr::function_ref expr, std::unique_ptr<reusable_context> ctx);
+    llvm_processor(analyze::expr::function_ref expr, jtl::ref<reusable_context> ctx);
     llvm_processor(llvm_processor const &) = delete;
     llvm_processor(llvm_processor &&) noexcept = default;