fix: lint

jank-lang · Jul 1, 2024 · ed9e317 · ed9e317
1 parent 1a0e64a
commit ed9e317
Show file tree

Hide file tree

Showing 4 changed files with 88 additions and 90 deletions.
diff --git a/compiler+runtime/src/cpp/jank/analyze/processor.cpp b/compiler+runtime/src/cpp/jank/analyze/processor.cpp
@@ -33,18 +33,18 @@ namespace jank::analyze
       };
     };
     specials = {
-      {        make_box<symbol>("def"),        make_fn(&processor::analyze_def) },
-      {        make_box<symbol>("fn*"),         make_fn(&processor::analyze_fn) },
-      {      make_box<symbol>("recur"),      make_fn(&processor::analyze_recur) },
-      {         make_box<symbol>("do"),         make_fn(&processor::analyze_do) },
-      {       make_box<symbol>("let*"),        make_fn(&processor::analyze_let) },
-      {      make_box<symbol>("loop*"),       make_fn(&processor::analyze_loop) },
-      {         make_box<symbol>("if"),         make_fn(&processor::analyze_if) },
-      {      make_box<symbol>("quote"),      make_fn(&processor::analyze_quote) },
-      {        make_box<symbol>("var"),   make_fn(&processor::analyze_var_call) },
-      {      make_box<symbol>("throw"),      make_fn(&processor::analyze_throw) },
-      {        make_box<symbol>("try"),        make_fn(&processor::analyze_try) },
-      { make_box<symbol>("native/raw"), make_fn(&processor::analyze_native_raw) },
+      {       make_box<symbol>("def"),        make_fn(&processor::analyze_def)},
+      {       make_box<symbol>("fn*"),         make_fn(&processor::analyze_fn)},
+      {     make_box<symbol>("recur"),      make_fn(&processor::analyze_recur)},
+      {        make_box<symbol>("do"),         make_fn(&processor::analyze_do)},
+      {      make_box<symbol>("let*"),        make_fn(&processor::analyze_let)},
+      {     make_box<symbol>("loop*"),       make_fn(&processor::analyze_loop)},
+      {        make_box<symbol>("if"),         make_fn(&processor::analyze_if)},
+      {     make_box<symbol>("quote"),      make_fn(&processor::analyze_quote)},
+      {       make_box<symbol>("var"),   make_fn(&processor::analyze_var_call)},
+      {     make_box<symbol>("throw"),      make_fn(&processor::analyze_throw)},
+      {       make_box<symbol>("try"),        make_fn(&processor::analyze_try)},
+      {make_box<symbol>("native/raw"), make_fn(&processor::analyze_native_raw)},
     };
   }
 
@@ -154,7 +154,7 @@ namespace jank::analyze
     }
 
     return make_box<expression>(expr::def<expression>{
-      expression_base{ {}, expr_type, current_frame, true },
+      expression_base{{}, expr_type, current_frame, true},
       qualified_sym,
       value_expr
     });
@@ -206,7 +206,7 @@ namespace jank::analyze
       }
 
       return make_box<expression>(expr::local_reference{
-        expression_base{ {}, expr_type, current_frame, needs_box },
+        expression_base{{}, expr_type, current_frame, needs_box},
         sym,
         unwrapped_local.binding
       });
@@ -228,7 +228,7 @@ namespace jank::analyze
       current_frame->lift_var(qualified_sym);
     }
     return make_box<expression>(expr::var_deref<expression>{
-      expression_base{ {}, expr_type, current_frame },
+      expression_base{{}, expr_type, current_frame},
       qualified_sym,
       unwrapped_var
     });
@@ -326,7 +326,7 @@ namespace jank::analyze
     fn_ctx->is_variadic = is_variadic;
     fn_ctx->param_count = param_symbols.size();
     expr::do_<expression> body_do{
-      expression_base{ {}, expression_type::return_statement, frame }
+      expression_base{{}, expression_type::return_statement, frame}
     };
     size_t const form_count{ list->count() - 1 };
     size_t i{};
@@ -351,10 +351,10 @@ namespace jank::analyze
     }
 
     return {
-      expr::function_arity<expression>{ std::move(param_symbols),
+      expr::function_arity<expression>{std::move(param_symbols),
                                        std::move(body_do),
                                        std::move(frame),
-                                       std::move(fn_ctx) }
+                                       std::move(fn_ctx)}
     };
   }
 
@@ -503,7 +503,7 @@ namespace jank::analyze
                    .to_string()))));
 
     auto ret(make_box<expression>(expr::function<expression>{
-      expression_base{ {}, expr_type, current_frame },
+      expression_base{{}, expr_type, current_frame},
       name,
       unique_name,
       std::move(arities),
@@ -578,7 +578,7 @@ namespace jank::analyze
     fn_ctx.unwrap()->is_tail_recursive = true;
 
     return make_box<expression>(expr::recur<expression>{
-      expression_base{ {}, expr_type, current_frame },
+      expression_base{{}, expr_type, current_frame},
       make_box<runtime::obj::persistent_list>(list->data.rest()),
       arg_exprs
     });
@@ -865,7 +865,7 @@ namespace jank::analyze
     }
 
     return make_box<expression>(expr::if_<expression>{
-      expression_base{ {}, expr_type, current_frame, needs_box },
+      expression_base{{}, expr_type, current_frame, needs_box},
       condition_expr.expect_ok(),
       then_expr.expect_ok(),
       else_expr_opt
@@ -919,7 +919,7 @@ namespace jank::analyze
     }
 
     return make_box<expression>(expr::var_ref<expression>{
-      expression_base{ {}, expr_type, current_frame, true },
+      expression_base{{}, expr_type, current_frame, true},
       qualified_sym,
       found_var.unwrap()
     });
@@ -935,7 +935,7 @@ namespace jank::analyze
     auto const qualified_sym(
       current_frame->lift_var(make_box<runtime::obj::symbol>(o->n->name->name, o->name->name)));
     return make_box<expression>(expr::var_ref<expression>{
-      expression_base{ {}, expr_type, current_frame, true },
+      expression_base{{}, expr_type, current_frame, true},
       qualified_sym,
       o
     });
@@ -961,7 +961,7 @@ namespace jank::analyze
     }
 
     return make_box<expression>(expr::throw_<expression>{
-      expression_base{ {}, expr_type, current_frame, true },
+      expression_base{{}, expr_type, current_frame, true},
       arg_expr.unwrap_move()
     });
   }
@@ -974,7 +974,7 @@ namespace jank::analyze
                          native_bool const)
   {
     expr::try_<expression> ret{
-      expression_base{ {}, expr_type, current_frame }
+      expression_base{{}, expr_type, current_frame}
     };
 
     /* Clojure JVM doesn't support recur across try/catch/finally, so we don't either. */
@@ -1166,8 +1166,8 @@ namespace jank::analyze
       /* Once we've found the start of an interpolation, we begin lexing/parsing at that
        * spot, so we can get a jank value. */
       read::lex::processor l_prc{
-        { code_str->data.data() + next_interp + interp_start.size(),
-         code_str->data.data() + code_str->data.size() }
+        {code_str->data.data() + next_interp + interp_start.size(),
+         code_str->data.data() + code_str->data.size()}
       };
       read::parse::processor p_prc{ l_prc.begin(), l_prc.end() };
       auto parsed_obj(p_prc.next());
@@ -1217,7 +1217,7 @@ namespace jank::analyze
     }
 
     return make_box<expression>(expr::native_raw<expression>{
-      expression_base{ {}, expr_type, current_frame, true },
+      expression_base{{}, expr_type, current_frame, true},
       std::move(chunks)
     });
   }
@@ -1231,7 +1231,7 @@ namespace jank::analyze
   {
     current_frame->lift_constant(o);
     return make_box<expression>(expr::primitive_literal<expression>{
-      expression_base{ {}, expr_type, current_frame, needs_box },
+      expression_base{{}, expr_type, current_frame, needs_box},
       o
     });
   }
@@ -1265,7 +1265,7 @@ namespace jank::analyze
     {
       /* Eval the literal to resolve exprs such as quotes. */
       auto const pre_eval_expr(make_box<expression>(expr::vector<expression>{
-        expression_base{ {}, expr_type, current_frame, true },
+        expression_base{{}, expr_type, current_frame, true},
         std::move(exprs),
         o->meta
       }));
@@ -1275,13 +1275,13 @@ namespace jank::analyze
       current_frame->lift_constant(o);
 
       return make_box<expression>(expr::primitive_literal<expression>{
-        expression_base{ {}, expr_type, current_frame, true },
+        expression_base{{}, expr_type, current_frame, true},
         o
       });
     }
 
     return make_box<expression>(expr::vector<expression>{
-      expression_base{ {}, expr_type, current_frame, true },
+      expression_base{{}, expr_type, current_frame, true},
       std::move(exprs),
       o->meta
     });
@@ -1314,7 +1314,7 @@ namespace jank::analyze
 
     /* TODO: Uniqueness check. */
     return make_box<expression>(expr::map<expression>{
-      expression_base{ {}, expr_type, current_frame, true },
+      expression_base{{}, expr_type, current_frame, true},
       std::move(exprs),
       o->meta
     });
@@ -1348,7 +1348,7 @@ namespace jank::analyze
     {
       /* Eval the literal to resolve exprs such as quotes. */
       auto const pre_eval_expr(make_box<expression>(expr::set<expression>{
-        expression_base{ {}, expr_type, current_frame, true },
+        expression_base{{}, expr_type, current_frame, true},
         std::move(exprs),
         o->meta
       }));
@@ -1358,13 +1358,13 @@ namespace jank::analyze
       current_frame->lift_constant(o);
 
       return make_box<expression>(expr::primitive_literal<expression>{
-        expression_base{ {}, expr_type, current_frame, true },
+        expression_base{{}, expr_type, current_frame, true},
         o
       });
     }
 
     return make_box<expression>(expr::set<expression>{
-      expression_base{ {}, expr_type, current_frame, true },
+      expression_base{{}, expr_type, current_frame, true},
       std::move(exprs),
       o->meta
     });
@@ -1489,7 +1489,7 @@ namespace jank::analyze
     }
 
     return make_box<expression>(expr::call<expression>{
-      expression_base{ {}, expr_type, current_frame, needs_ret_box },
+      expression_base{{}, expr_type, current_frame, needs_ret_box},
       source,
       make_box<runtime::obj::persistent_list>(o->data.rest()),
       arg_exprs,

diff --git a/compiler+runtime/src/cpp/jank/evaluate.cpp b/compiler+runtime/src/cpp/jank/evaluate.cpp
@@ -52,10 +52,10 @@ namespace jank::evaluate
     if(exprs.empty())
     {
       return wrap_expression(analyze::expr::primitive_literal<analyze::expression>{
-        analyze::expression_base{ {},
+        analyze::expression_base{{},
                                  analyze::expression_type::return_statement,
                                  an_prc.root_frame,
-                                 true },
+                                 true},
         runtime::obj::nil::nil_const()
       });
     }

diff --git a/compiler+runtime/src/cpp/jank/read/parse.cpp b/compiler+runtime/src/cpp/jank/read/parse.cpp
@@ -344,9 +344,7 @@ namespace jank::read::parse
     ++token_current;
     auto const sv(boost::get<native_persistent_string_view>(token.data));
 
-    return object_source_info{ make_box<runtime::obj::character>(sv),
-                               token,
-                               token };
+    return object_source_info{ make_box<runtime::obj::character>(sv), token, token };
   }
 
   processor::object_result processor::parse_meta_hint()

diff --git a/compiler+runtime/src/cpp/jank/runtime/util.cpp b/compiler+runtime/src/cpp/jank/runtime/util.cpp
@@ -51,59 +51,59 @@ namespace jank::runtime
   }
 
   static native_unordered_map<char, native_persistent_string_view> const munge_chars{
-    {  '-',        "_" },
-    {  ':',  "_COLON_" },
-    {  '+',   "_PLUS_" },
-    {  '>',     "_GT_" },
-    {  '<',     "_LT_" },
-    {  '=',     "_EQ_" },
-    {  '~',  "_TILDE_" },
-    {  '!',   "_BANG_" },
-    {  '@',  "_CIRCA_" },
-    {  '#',  "_SHARP_" },
-    { '\'', "_SQUOTE_" },
-    {  '"', "_DQUOTE_" },
-    {  '%',   "_PERC_" },
-    {  '^',  "_CARET_" },
-    {  '&',    "_AMP_" },
-    {  '*',   "_STAR_" },
-    {  '|',    "_BAR_" },
-    {  '{', "_LBRACE_" },
-    {  '}', "_RBRACE_" },
-    {  '[', "_LBRACK_" },
-    {  ']', "_RBRACK_" },
-    {  '/',  "_SLASH_" },
-    { '\\', "_BSLASH_" },
-    {  '?',  "_QMARK_" }
+    { '-',        "_"},
+    { ':',  "_COLON_"},
+    { '+',   "_PLUS_"},
+    { '>',     "_GT_"},
+    { '<',     "_LT_"},
+    { '=',     "_EQ_"},
+    { '~',  "_TILDE_"},
+    { '!',   "_BANG_"},
+    { '@',  "_CIRCA_"},
+    { '#',  "_SHARP_"},
+    {'\'', "_SQUOTE_"},
+    { '"', "_DQUOTE_"},
+    { '%',   "_PERC_"},
+    { '^',  "_CARET_"},
+    { '&',    "_AMP_"},
+    { '*',   "_STAR_"},
+    { '|',    "_BAR_"},
+    { '{', "_LBRACE_"},
+    { '}', "_RBRACE_"},
+    { '[', "_LBRACK_"},
+    { ']', "_RBRACK_"},
+    { '/',  "_SLASH_"},
+    {'\\', "_BSLASH_"},
+    { '?',  "_QMARK_"}
   };
 
   /* This is sorted from longest to shortest so we can check for the longest first. This
    * allows some entries to be prefixes of others without ambiguity. */
   static native_vector<std::pair<native_persistent_string_view, char>> const demunge_chars{
-    { "_LBRACE_",  '{' },
-    { "_RBRACE_",  '}' },
-    { "_LBRACK_",  '[' },
-    { "_RBRACK_",  ']' },
-    { "_BSLASH_", '\\' },
-    { "_SQUOTE_", '\'' },
-    { "_DQUOTE_",  '"' },
-    {  "_QMARK_",  '?' },
-    {  "_COLON_",  ':' },
-    {  "_TILDE_",  '~' },
-    {  "_CIRCA_",  '@' },
-    {  "_SHARP_",  '#' },
-    {  "_CARET_",  '^' },
-    {  "_SLASH_",  '/' },
-    {   "_PERC_",  '%' },
-    {   "_PLUS_",  '+' },
-    {   "_BANG_",  '!' },
-    {   "_STAR_",  '*' },
-    {    "_AMP_",  '&' },
-    {    "_BAR_",  '|' },
-    {     "_GT_",  '>' },
-    {     "_LT_",  '<' },
-    {     "_EQ_",  '=' },
-    {        "_",  '-' },
+    {"_LBRACE_",  '{'},
+    {"_RBRACE_",  '}'},
+    {"_LBRACK_",  '['},
+    {"_RBRACK_",  ']'},
+    {"_BSLASH_", '\\'},
+    {"_SQUOTE_", '\''},
+    {"_DQUOTE_",  '"'},
+    { "_QMARK_",  '?'},
+    { "_COLON_",  ':'},
+    { "_TILDE_",  '~'},
+    { "_CIRCA_",  '@'},
+    { "_SHARP_",  '#'},
+    { "_CARET_",  '^'},
+    { "_SLASH_",  '/'},
+    {  "_PERC_",  '%'},
+    {  "_PLUS_",  '+'},
+    {  "_BANG_",  '!'},
+    {  "_STAR_",  '*'},
+    {   "_AMP_",  '&'},
+    {   "_BAR_",  '|'},
+    {    "_GT_",  '>'},
+    {    "_LT_",  '<'},
+    {    "_EQ_",  '='},
+    {       "_",  '-'},
   };
 
   /* https://en.cppreference.com/w/cpp/keyword */