Implement support for typed catch clauses

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/codegen/processor.hpp

@@ -171,7 +171,7 @@ namespace jank::codegen
     void build_footer();
     jtl::immutable_string expression_str(bool box_needed);
 
-    jtl::immutable_string module_init_str(jtl::immutable_string const &module);
+    jtl::immutable_string module_init_str(jtl::immutable_string const &module_name);
 
     void format_elided_var(jtl::immutable_string const &start,
                            jtl::immutable_string const &end,

compiler+runtime/include/cpp/jank/detail/to_runtime_data.hpp

@@ -1,13 +1,15 @@
 #pragma once
 
+
 #include <filesystem>
 
 #include <jtl/ptr.hpp>
 
-#include <jank/runtime/obj/symbol.hpp>
-#include <jank/runtime/obj/persistent_array_map.hpp>
 #include <jank/runtime/core/make_box.hpp>
 #include <jank/runtime/core/seq.hpp>
+#include <jank/runtime/obj/persistent_array_map.hpp>
+#include <jank/runtime/obj/symbol.hpp>
+#include <jank/runtime/obj/transient_vector.hpp>
 
 namespace jank::detail
 {
@@ -100,4 +102,16 @@ namespace jank::detail
   {
     return m;
   }
+
+  template <typename T>
+  object_ref to_runtime_data(native_vector<T> const &m)
+  {
+    /* NOLINTNEXTLINE(misc-const-correctness): Can't be const. */
+    runtime::detail::native_persistent_vector ret;
+    for(auto const &e : m)
+    {
+      (void)ret.push_back(to_runtime_data(e));
+    }
+    return make_box<obj::persistent_vector>(ret);
+  }
 }

compiler+runtime/src/cpp/jank/analyze/cpp_util.cpp

@@ -71,6 +71,17 @@ namespace jank::analyze::cpp_util
 
   jtl::ptr<void> resolve_type(jtl::immutable_string const &sym, u8 const ptr_count)
   {
+    /* Clang canonicalizes "char" to "signed char" on some platforms, which breaks exception
+     * handling since they are distinct types. We use resolve_literal_type to get the
+     * exact type for "char". */
+    if(sym == "char")
+    {
+      if(auto const res{ resolve_literal_type("char").expect_ok() })
+      {
+        return apply_pointers(res, ptr_count);
+      }
+    }
+
     auto const type{ Cpp::GetType(sym) };
     if(type)
     {

compiler+runtime/src/cpp/jank/analyze/expr/try.cpp

@@ -34,11 +34,14 @@ namespace jank::analyze::expr
   {
     position = pos;
     body->propagate_position(pos);
-    if(catch_body)
+    if(!catch_bodies.empty())
     {
-      catch_body.unwrap().propagate_position(pos);
+      for(auto const &catch_body : catch_bodies)
+      {
+        catch_body.propagate_position(pos);
+      }
     }
-    /* The result of the 'finally' body is discarded, so we always keep it in statement position. */
+    /* The result of the 'finally' body is discarded, so we always keep it in the statement position. */
   }
 
   runtime::object_ref try_::to_runtime_data() const
@@ -50,17 +53,20 @@ namespace jank::analyze::expr
       persistent_array_map::create_unique(make_box("body"),
                                           body->to_runtime_data(),
                                           make_box("catch"),
-                                          jank::detail::to_runtime_data(catch_body),
+                                          jank::detail::to_runtime_data(catch_bodies),
                                           make_box("finally"),
                                           jank::detail::to_runtime_data(finally_body)));
   }
 
   void try_::walk(std::function<void(jtl::ref<expression>)> const &f)
   {
     f(body);
-    if(catch_body.is_some())
+    if(!catch_bodies.empty())
     {
-      f(catch_body.unwrap().body);
+      for(auto const &catch_body : catch_bodies)
+      {
+        f(catch_body.body);
+      }
     }
     if(finally_body.is_some())
     {

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

@@ -2259,7 +2259,7 @@ namespace jank::analyze
 
     /* All bindings in a letfn appear simultaneously and may be mutually recursive.
      * This makes creating a letfn locals frame a bit more involved than let, where locals
-     * are introduced left-to-right. For example, each binding in (letfn [(a [] b) (b [] a)]) 
+     * are introduced left-to-right. For example, each binding in (letfn [(a [] b) (b [] a)])
      * requires the other to be in scope in order to be analyzed.
      *
      * We tackle this in two steps. First, we create empty local bindings for all names.
@@ -2616,7 +2616,6 @@ namespace jank::analyze
     auto try_frame(jtl::make_ref<local_frame>(local_frame::frame_type::try_, current_frame));
     /* We introduce a new frame so that we can register the sym as a local.
      * It holds the exception value which was caught. */
-    auto catch_frame(jtl::make_ref<local_frame>(local_frame::frame_type::catch_, current_frame));
     auto finally_frame(jtl::make_ref<local_frame>(local_frame::frame_type::finally, current_frame));
     auto ret{ jtl::make_ref<expr::try_>(position, try_frame, true, jtl::make_ref<expr::do_>()) };
 
@@ -2701,69 +2700,124 @@ namespace jank::analyze
                 object_source(item),
                 latest_expansion(macro_expansions));
             }
-            if(has_catch)
-            {
-              /* TODO: Note where the other catch is. */
-              return error::analyze_invalid_try("Only one 'catch' form may be supplied.",
-                                                object_source(item),
-                                                latest_expansion(macro_expansions));
-            }
             has_catch = true;
 
-            /* Verify we have (catch <sym> ...) */
+            /* Verify we have (catch cpp/type <sym> ...) */
             auto const catch_list(runtime::list(item));
-            auto const catch_body_size(catch_list->count());
-            if(catch_body_size == 1)
+            if(auto const catch_body_size(catch_list->count()); catch_body_size < 2)
             {
               return error::analyze_invalid_try(
-                "A symbol is required after 'catch', which is used as the binding to "
-                "hold the exception value.",
+                "Each 'catch' form requires the type of exception to catch and a symbol for the "
+                "name of the exception value.",
                 object_source(item),
                 latest_expansion(macro_expansions));
             }
+            auto catch_it(catch_list->data.rest());
+            auto const catch_type_form(catch_it.first().unwrap());
+            catch_it = catch_it.rest();
+            auto const catch_sym_form(catch_it.first().unwrap());
+            auto const catch_type(analyze(catch_type_form, current_frame, position, fn_ctx, true));
+            if(catch_type.is_err())
+            {
+              return error::analyze_invalid_try(catch_type.expect_err()->message,
+                                                object_source(item),
+                                                error::note{
+                                                  "An exception type is required before this form.",
+                                                  object_source(catch_sym_form),
+                                                },
+                                                latest_expansion(macro_expansions))
+                ->add_usage(read::parse::reparse_nth(item, 1));
+            }
+
+            if(catch_type.expect_ok()->kind != expression_kind::cpp_type)
+            {
+              return error::analyze_invalid_try("Exception is not a type.",
+                                                object_source(item),
+                                                error::note{
+                                                  "An exception type is required before this form.",
+                                                  object_source(catch_sym_form),
+                                                },
+                                                latest_expansion(macro_expansions))
+                ->add_usage(read::parse::reparse_nth(item, 1));
+            }
 
-            auto const sym_obj(catch_list->data.rest().first().unwrap());
-            if(sym_obj->type != runtime::object_type::symbol)
+            if(catch_sym_form->type != runtime::object_type::symbol)
             {
               return error::analyze_invalid_try(
-                       "A symbol required after 'catch', which is used as the binding to "
+                       "A symbol is required after 'catch', which is used as the binding to "
                        "hold the exception value.",
                        object_source(item),
                        error::note{
                          "A symbol is required before this form.",
-                         object_source(sym_obj),
+                         object_source(catch_sym_form),
                        },
                        latest_expansion(macro_expansions))
-                ->add_usage(read::parse::reparse_nth(item, 1));
+                ->add_usage(read::parse::reparse_nth(item, 2));
+            }
+            auto const catch_sym(runtime::expect_object<runtime::obj::symbol>(catch_sym_form));
+            if(!catch_sym->get_namespace().empty())
+            {
+              return error::analyze_invalid_try(
+                "The binding symbol in 'catch' must be unqualified.",
+                object_source(item),
+                latest_expansion(macro_expansions));
             }
+            auto const catch_type_ref(static_ref_cast<expr::cpp_type>(catch_type.expect_ok()));
+            /* If we're catching a C++ class/struct by value, we want to promote it to a reference
+             * to avoid object slicing and to enable polymorphism.
+             * However, we must NOT promote types in the jank::runtime namespace (like object_ref),
+             * as these are smart pointers expected to be passed by value in the runtime. */
+            if(!Cpp::IsPointerType(catch_type_ref->type)
+               && !Cpp::IsReferenceType(catch_type_ref->type)
+               && !Cpp::IsBuiltin(catch_type_ref->type))
+            {
+              /* Check if this type is in the jank::runtime namespace */
+              auto const type_scope{ Cpp::GetScopeFromType(catch_type_ref->type) };
+              auto const type_name{ cpp_util::get_qualified_name(type_scope) };
+              bool const is_jank_runtime_type{ type_name.find("jank::runtime::") == 0 };
 
-            auto const sym(runtime::expect_object<runtime::obj::symbol>(sym_obj));
-            if(!sym->get_namespace().empty())
+              if(!is_jank_runtime_type)
+              {
+                catch_type_ref->type = Cpp::GetLValueReferenceType(catch_type_ref->type);
+              }
+            }
+
+            /* Check for duplicate catch types. */
+            /*TODO Add full error handling for duplicated catch types:
+             * Add a new error kind and notes pointing to the duplicated types*/
+            for(auto const &existing_catch : ret->catch_bodies)
             {
-              return error::analyze_invalid_try("The symbol after 'catch' must be unqualified.",
-                                                object_source(sym_obj),
-                                                latest_expansion(macro_expansions));
+              if(existing_catch.type.data == catch_type_ref->type.data)
+              {
+                return error::analyze_invalid_try("Each catch form must specify a unique type.",
+                                                  object_source(item),
+                                                  latest_expansion(macro_expansions));
+              }
             }
 
-            catch_frame->locals.emplace(sym, local_binding{ sym, sym->name, none, catch_frame });
+            auto catch_frame(
+              jtl::make_ref<local_frame>(local_frame::frame_type::catch_, current_frame));
+            catch_frame->locals.emplace(catch_sym,
+                                        local_binding{ catch_sym,
+                                                       catch_sym->name,
+                                                       none,
+                                                       catch_frame,
+                                                       true,
+                                                       false,
+                                                       false,
+                                                       catch_type_ref->type });
 
             /* Now we just turn the body into a do block and have the do analyzer handle the rest. */
-            auto const do_list(
-              catch_list->data.rest().rest().conj(make_box<runtime::obj::symbol>("do")));
+            auto const do_list(catch_it.rest().conj(make_box<runtime::obj::symbol>("do")));
             auto const do_res(analyze(make_box(do_list), catch_frame, position, fn_ctx, true));
             if(do_res.is_err())
             {
               return do_res.expect_err();
             }
-
-            /* TODO: Read this from the catch form. */
-            static auto const object_ref_type{ cpp_util::resolve_literal_type(
-                                                 "jank::runtime::oref<jank::runtime::object>")
-                                                 .expect_ok() };
-
-            ret->catch_body = expr::catch_{ sym,
-                                            object_ref_type,
-                                            static_ref_cast<expr::do_>(do_res.expect_ok()) };
+            do_res.expect_ok()->frame = catch_frame;
+            ret->catch_bodies.emplace_back(catch_sym,
+                                           catch_type_ref->type,
+                                           static_ref_cast<expr::do_>(do_res.expect_ok()));
           }
           break;
         case try_expression_type::finally_:
@@ -2797,10 +2851,6 @@ namespace jank::analyze
 
     ret->body->frame = try_frame;
     ret->body->propagate_position(position);
-    if(ret->catch_body.is_some())
-    {
-      ret->catch_body.unwrap().body->frame = catch_frame;
-    }
     if(ret->finally_body.is_some())
     {
       ret->finally_body.unwrap()->frame = finally_frame;
@@ -2861,12 +2911,12 @@ namespace jank::analyze
       /* Eval the literal to resolve exprs such as quotes. */
       auto const pre_eval_expr(
         jtl::make_ref<expr::vector>(position, current_frame, true, std::move(exprs), o->meta));
-      auto const o(evaluate::eval(pre_eval_expr));
+      auto const oref(evaluate::eval(pre_eval_expr));
 
       /* TODO: Order lifted constants. Use sub constants during codegen. */
-      current_frame->lift_constant(o);
+      current_frame->lift_constant(oref);
 
-      return jtl::make_ref<expr::primitive_literal>(position, current_frame, true, o);
+      return jtl::make_ref<expr::primitive_literal>(position, current_frame, true, oref);
     }
 
     return jtl::make_ref<expr::vector>(position, current_frame, true, std::move(exprs), o->meta);