feat: set parsing syntax quotes (#392)

* Set parsing syntax quotes

* update commit sha

* Lint

* Try again

Author: E-A-Griffin

compiler+runtime/include/cpp/jank/read/parse.hpp

@@ -96,6 +96,7 @@ namespace jank::read::parse
   private:
     jtl::result<runtime::object_ref, error_ref> syntax_quote(runtime::object_ref form);
     jtl::result<runtime::object_ref, error_ref> syntax_quote_expand_seq(runtime::object_ref seq);
+    jtl::result<runtime::object_ref, error_ref> syntax_quote_expand_set(runtime::object_ref seq);
     static jtl::result<runtime::object_ref, error_ref>
     syntax_quote_flatten_map(runtime::object_ref seq);
     static bool syntax_quote_is_unquote(runtime::object_ref form, bool splice);

compiler+runtime/src/cpp/jank/read/parse.cpp

@@ -983,6 +983,51 @@ namespace jank::read::parse
       seq);
   }
 
+  jtl::result<object_ref, error_ref> processor::syntax_quote_expand_set(object_ref const seq)
+  {
+    if(seq.is_nil())
+    {
+      return seq;
+    }
+
+    return visit_seqable(
+      [this](auto const typed_seq) -> jtl::result<object_ref, error_ref> {
+        runtime::detail::native_transient_vector ret;
+        for(auto const item : make_sequence_range(typed_seq))
+        {
+          if(syntax_quote_is_unquote(item, false))
+          {
+            ret.push_back(
+              make_box<obj::persistent_list>(std::in_place,
+                                             make_box<obj::symbol>("clojure.core", "list"),
+                                             second(item)));
+          }
+          else if(syntax_quote_is_unquote(item, true))
+          {
+            ret.push_back(second(item));
+          }
+          else
+          {
+            auto quoted_item(syntax_quote(item));
+            if(quoted_item.is_err())
+            {
+              return quoted_item;
+            }
+            ret.push_back(
+              make_box<obj::persistent_list>(std::in_place,
+                                             make_box<obj::symbol>("clojure.core", "list"),
+                                             quoted_item.expect_ok()));
+          }
+        }
+        auto const vec(make_box<obj::persistent_vector>(ret.persistent())->seq());
+        return vec;
+      },
+      []() -> jtl::result<object_ref, error_ref> {
+        return err(error::internal_parse_failure("syntax_quote_expand_seq arg not seqable."));
+      },
+      seq);
+  }
+
   bool processor::syntax_quote_is_unquote(object_ref const form, bool const splice)
   {
     return visit_seqable(
@@ -1118,7 +1163,27 @@ namespace jank::read::parse
           }
           if constexpr(behavior::set_like<T>)
           {
-            return err(error::internal_parse_failure("nyi: set"));
+            auto const seq(typed_form->seq());
+            if(seq.is_nil())
+            {
+              return make_box<obj::persistent_list>(
+                std::in_place,
+                make_box<obj::symbol>("clojure.core", "hash-set"));
+            }
+            auto expanded(syntax_quote_expand_seq(seq));
+            if(expanded.is_err())
+            {
+              return expanded;
+            }
+
+            return make_box<obj::persistent_list>(
+              std::in_place,
+              make_box<obj::symbol>("clojure.core", "apply*"),
+              make_box<obj::symbol>("clojure.core", "hash-set"),
+              make_box<obj::persistent_list>(
+                std::in_place,
+                make_box<obj::symbol>("clojure.core", "seq"),
+                cons(make_box<obj::symbol>("clojure.core", "concat*"), expanded.expect_ok())));
           }
           if constexpr(behavior::sequenceable<T>)
           {

compiler+runtime/test/jank/syntax-quote/pass-unaffected.jank

@@ -13,6 +13,7 @@
   (assert (= :syntax-quote.pass-unaffected/bar `::c/bar) `::c/bar)
   (assert (= [] `[]) `[])
   (assert (= {} `{}) `{})
+  (assert (= #{} `#{}) `#{})
   (assert (= '() `()) `())
   (assert (= "meow" `"meow") `"meow")
   (assert (= 'foo/meow `foo/meow) `foo/meow)

compiler+runtime/test/jank/syntax-quote/unquote-splice/pass-values.jank

@@ -3,6 +3,7 @@
       a [1 2 3]]
   (assert (= '(clojure.core/str) `(str ~@e)))
   (assert (= '(clojure.core/str 1 2 3) `(str ~@a)))
-  (assert (= [1 2 3 0 1 2 3] `[~@e ~@a ~@b ~@a ~@e])))
+  (assert (= [1 2 3 0 1 2 3] `[~@e ~@a ~@b ~@a ~@e]))
+  (assert (= #{1 2 3 0} `#{~@e ~@a ~@b})))
 
 :success