Remove nullptr usage from parse processor

jeaye · jeaye · commit 04dfd13f3713 · 2024-03-09T06:53:08.000Z
diff --git a/include/cpp/jank/read/lex.hpp b/include/cpp/jank/read/lex.hpp
@@ -67,7 +67,7 @@ namespace jank::read::lex
     static constexpr size_t ignore_pos{ std::numeric_limits<size_t>::max() };
     size_t pos{ ignore_pos };
     size_t size{ 1 };
-    token_kind kind;
+    token_kind kind{ token_kind::eof };
     boost::variant<no_data, native_integer, native_real, native_persistent_string_view, native_bool>
       data;
   };
diff --git a/include/cpp/jank/read/parse.hpp b/include/cpp/jank/read/parse.hpp
@@ -14,8 +14,15 @@ namespace jank::read::parse
 {
   struct processor
   {
-    /* TODO: none instead of nullptr. */
-    using object_result = result<runtime::object_ptr, error>;
+    struct object_source_info
+    {
+      native_bool operator==(object_source_info const &rhs) const;
+      native_bool operator!=(object_source_info const &rhs) const;
+
+      runtime::object_ptr ptr{};
+    };
+
+    using object_result = result<option<object_source_info>, error>;
 
     struct iterator
     {
diff --git a/src/cpp/jank/analyze/processor.cpp b/src/cpp/jank/analyze/processor.cpp
@@ -65,7 +65,7 @@ namespace jank::analyze
       {
         return err(parse_current->expect_err_move());
       }
-      fn.push_back(parse_current->expect_ok());
+      fn.push_back(parse_current->expect_ok().unwrap().ptr);
     }
     auto fn_list(make_box<runtime::obj::persistent_list>(fn.rbegin(), fn.rend()));
     return analyze(fn_list, expression_type::expression);
@@ -986,8 +986,11 @@ namespace jank::analyze
       {
         return parsed_it->expect_err_move();
       }
-      auto result(
-        analyze(parsed_it->expect_ok(), current_frame, expression_type::expression, fn_ctx, true));
+      auto result(analyze(parsed_it->expect_ok().unwrap().ptr,
+                          current_frame,
+                          expression_type::expression,
+                          fn_ctx,
+                          true));
       if(result.is_err())
       {
         return result.expect_err_move();
diff --git a/src/cpp/jank/read/parse.cpp b/src/cpp/jank/read/parse.cpp
@@ -66,6 +66,18 @@ namespace jank::read::parse
     }
   }
 
+  native_bool
+  processor::object_source_info::operator==(processor::object_source_info const &rhs) const
+  {
+    return !(*this != rhs);
+  }
+
+  native_bool
+  processor::object_source_info::operator!=(processor::object_source_info const &rhs) const
+  {
+    return ptr != rhs.ptr;
+  }
+
   processor::iterator::value_type processor::iterator::operator*() const
   {
     return latest.unwrap();
@@ -109,10 +121,9 @@ namespace jank::read::parse
 
   processor::object_result processor::next()
   {
-    /* TODO: Replace nullptr with none. */
     if(token_current == token_end)
     {
-      return ok(nullptr);
+      return ok(none);
     }
 
     while(true)
@@ -146,7 +157,7 @@ namespace jank::read::parse
           }
           ++token_current;
           expected_closer = none;
-          return ok(nullptr);
+          return ok(none);
         case lex::token_kind::single_quote:
           return parse_quote();
         case lex::token_kind::nil:
@@ -166,7 +177,7 @@ namespace jank::read::parse
         case lex::token_kind::escaped_string:
           return parse_escaped_string();
         case lex::token_kind::eof:
-          return ok(nullptr);
+          return ok(none);
         default:
           {
             native_persistent_string msg{ fmt::format("unexpected token kind: {}",
@@ -191,15 +202,15 @@ namespace jank::read::parse
       {
         return err(it.latest.unwrap().expect_err());
       }
-      ret.push_back(it.latest.unwrap().expect_ok());
+      ret.push_back(it.latest.unwrap().expect_ok().unwrap().ptr);
     }
     if(expected_closer.is_some())
     {
       return err(error{ start_token.pos, "Unterminated list" });
     }
 
     expected_closer = prev_expected_closer;
-    return make_box<runtime::obj::persistent_list>(ret.rbegin(), ret.rend());
+    return object_source_info{ make_box<runtime::obj::persistent_list>(ret.rbegin(), ret.rend()) };
   }
 
   processor::object_result processor::parse_vector()
@@ -216,15 +227,15 @@ namespace jank::read::parse
       {
         return err(it.latest.unwrap().expect_err());
       }
-      ret.push_back(it.latest.unwrap().expect_ok());
+      ret.push_back(it.latest.unwrap().expect_ok().unwrap().ptr);
     }
     if(expected_closer.is_some())
     {
       return err(error{ start_token.pos, "Unterminated vector" });
     }
 
     expected_closer = prev_expected_closer;
-    return make_box<runtime::obj::persistent_vector>(ret.persistent());
+    return object_source_info{ make_box<runtime::obj::persistent_vector>(ret.persistent()) };
   }
 
   /* TODO: Uniqueness check. */
@@ -255,15 +266,15 @@ namespace jank::read::parse
       }
       auto const value(it.latest.unwrap().expect_ok());
 
-      ret.insert_or_assign(key, value);
+      ret.insert_or_assign(key.unwrap().ptr, value.unwrap().ptr);
     }
     if(expected_closer.is_some())
     {
       return err(error{ start_token.pos, "Unterminated map" });
     }
 
     expected_closer = prev_expected_closer;
-    return make_box<runtime::obj::persistent_array_map>(ret);
+    return object_source_info{ make_box<runtime::obj::persistent_array_map>(ret) };
   }
 
   processor::object_result processor::parse_quote()
@@ -278,28 +289,28 @@ namespace jank::read::parse
     {
       return val_result;
     }
-    else if(val_result.expect_ok() == nullptr)
+    else if(val_result.expect_ok().is_none())
     {
       return err(error{ start_token.pos, native_persistent_string{ "invalid value after quote" } });
     }
 
-    return runtime::erase(
+    return object_source_info{ runtime::erase(
       make_box<runtime::obj::persistent_list>(make_box<runtime::obj::symbol>("quote"),
-                                              val_result.expect_ok_move()));
+                                              val_result.expect_ok().unwrap().ptr)) };
   }
 
   processor::object_result processor::parse_nil()
   {
     ++token_current;
-    return ok(runtime::obj::nil::nil_const());
+    return object_source_info{ runtime::obj::nil::nil_const() };
   }
 
   processor::object_result processor::parse_boolean()
   {
     auto const token((*token_current).expect_ok());
     ++token_current;
     auto const b(boost::get<native_bool>(token.data));
-    return ok(make_box<runtime::obj::boolean>(b));
+    return object_source_info{ make_box<runtime::obj::boolean>(b) };
   }
 
   processor::object_result processor::parse_symbol()
@@ -341,7 +352,7 @@ namespace jank::read::parse
     {
       name = sv;
     }
-    return ok(make_box<runtime::obj::symbol>(ns, name));
+    return object_source_info{ make_box<runtime::obj::symbol>(ns, name) };
   }
 
   processor::object_result processor::parse_keyword()
@@ -377,30 +388,31 @@ namespace jank::read::parse
     {
       return err(intern_res.expect_err());
     }
-    return ok(intern_res.expect_ok());
+    return object_source_info{ intern_res.expect_ok() };
   }
 
   processor::object_result processor::parse_integer()
   {
     auto const token(token_current->expect_ok());
     ++token_current;
-    return ok(make_box<runtime::obj::integer>(boost::get<native_integer>(token.data)));
+    return object_source_info{ make_box<runtime::obj::integer>(
+      boost::get<native_integer>(token.data)) };
   }
 
   processor::object_result processor::parse_real()
   {
     auto const token(token_current->expect_ok());
     ++token_current;
-    return ok(make_box<runtime::obj::real>(boost::get<native_real>(token.data)));
+    return object_source_info{ make_box<runtime::obj::real>(boost::get<native_real>(token.data)) };
   }
 
   processor::object_result processor::parse_string()
   {
     auto const token(token_current->expect_ok());
     ++token_current;
     auto const sv(boost::get<native_persistent_string_view>(token.data));
-    return ok(
-      make_box<runtime::obj::persistent_string>(native_persistent_string{ sv.data(), sv.size() }));
+    return object_source_info{ make_box<runtime::obj::persistent_string>(
+      native_persistent_string{ sv.data(), sv.size() }) };
   }
 
   processor::object_result processor::parse_escaped_string()
@@ -413,7 +425,7 @@ namespace jank::read::parse
     {
       return err(error{ token.pos, res.expect_err_move() });
     }
-    return ok(make_box<runtime::obj::persistent_string>(res.expect_ok_move()));
+    return object_source_info{ make_box<runtime::obj::persistent_string>(res.expect_ok_move()) };
   }
 
   processor::iterator processor::begin()
@@ -423,6 +435,6 @@ namespace jank::read::parse
 
   processor::iterator processor::end()
   {
-    return { some(ok(nullptr)), *this };
+    return { some(ok(none)), *this };
   }
 }
diff --git a/src/cpp/jank/runtime/context.cpp b/src/cpp/jank/runtime/context.cpp
@@ -197,7 +197,8 @@ namespace jank::runtime
     native_vector<analyze::expression_ptr> exprs{};
     for(auto const &form : p_prc)
     {
-      auto const expr(an_prc.analyze(form.expect_ok(), analyze::expression_type::statement));
+      auto const expr(
+        an_prc.analyze(form.expect_ok().unwrap().ptr, analyze::expression_type::statement));
       ret = evaluate::eval(*this, jit_prc, expr.expect_ok());
       exprs.emplace_back(expr.expect_ok());
     }
@@ -230,7 +231,8 @@ namespace jank::runtime
     native_vector<analyze::expression_ptr> ret{};
     for(auto const &form : p_prc)
     {
-      auto const expr(an_prc.analyze(form.expect_ok(), analyze::expression_type::statement));
+      auto const expr(
+        an_prc.analyze(form.expect_ok().unwrap().ptr, analyze::expression_type::statement));
       if(eval)
       {
         evaluate::eval(*this, jit_prc, expr.expect_ok());
diff --git a/test/cpp/jank/read/parse.cpp b/test/cpp/jank/read/parse.cpp

Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,15 @@ namespace jank::read::parse`
`14`	`14`	`{`
`15`	`15`	`struct processor`
`16`	`16`	`{`
`17`		`- /* TODO: none instead of nullptr. */`
`18`		`- using object_result = result<runtime::object_ptr, error>;`
	`17`	`+ struct object_source_info`
	`18`	`+ {`
	`19`	`+ native_bool operator==(object_source_info const &rhs) const;`
	`20`	`+ native_bool operator!=(object_source_info const &rhs) const;`
	`21`	`+`
	`22`	`+ runtime::object_ptr ptr{};`
	`23`	`+ };`
	`24`	`+`
	`25`	`+ using object_result = result<option<object_source_info>, error>;`
`19`	`26`
`20`	`27`	`struct iterator`
`21`	`28`	`{`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ namespace jank::analyze`
`65`	`65`	`{`
`66`	`66`	`return err(parse_current->expect_err_move());`
`67`	`67`	`}`
`68`		`- fn.push_back(parse_current->expect_ok());`
	`68`	`+ fn.push_back(parse_current->expect_ok().unwrap().ptr);`
`69`	`69`	`}`
`70`	`70`	`auto fn_list(make_box<runtime::obj::persistent_list>(fn.rbegin(), fn.rend()));`
`71`	`71`	`return analyze(fn_list, expression_type::expression);`
`@@ -986,8 +986,11 @@ namespace jank::analyze`
`986`	`986`	`{`
`987`	`987`	`return parsed_it->expect_err_move();`
`988`	`988`	`}`
`989`		`- auto result(`
`990`		`- analyze(parsed_it->expect_ok(), current_frame, expression_type::expression, fn_ctx, true));`
	`989`	`+ auto result(analyze(parsed_it->expect_ok().unwrap().ptr,`
	`990`	`+ current_frame,`
	`991`	`+ expression_type::expression,`
	`992`	`+ fn_ctx,`
	`993`	`+ true));`
`991`	`994`	`if(result.is_err())`
`992`	`995`	`{`
`993`	`996`	`return result.expect_err_move();`
Original file line number	Diff line number	Diff line change
`@@ -66,6 +66,18 @@ namespace jank::read::parse`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
	`69`	`+ native_bool`
	`70`	`+ processor::object_source_info::operator==(processor::object_source_info const &rhs) const`
	`71`	`+ {`
	`72`	`+ return !(*this != rhs);`
	`73`	`+ }`
	`74`	`+`
	`75`	`+ native_bool`
	`76`	`+ processor::object_source_info::operator!=(processor::object_source_info const &rhs) const`
	`77`	`+ {`
	`78`	`+ return ptr != rhs.ptr;`
	`79`	`+ }`
	`80`	`+`
`69`	`81`	`processor::iterator::value_type processor::iterator::operator*() const`
`70`	`82`	`{`
`71`	`83`	`return latest.unwrap();`
`@@ -109,10 +121,9 @@ namespace jank::read::parse`
`109`	`121`
`110`	`122`	`processor::object_result processor::next()`
`111`	`123`	`{`
`112`		`- /* TODO: Replace nullptr with none. */`
`113`	`124`	`if(token_current == token_end)`
`114`	`125`	`{`
`115`		`- return ok(nullptr);`
	`126`	`+ return ok(none);`
`116`	`127`	`}`
`117`	`128`
`118`	`129`	`while(true)`
`@@ -146,7 +157,7 @@ namespace jank::read::parse`
`146`	`157`	`}`
`147`	`158`	`++token_current;`
`148`	`159`	`expected_closer = none;`
`149`		`- return ok(nullptr);`
	`160`	`+ return ok(none);`
`150`	`161`	`case lex::token_kind::single_quote:`
`151`	`162`	`return parse_quote();`
`152`	`163`	`case lex::token_kind::nil:`
`@@ -166,7 +177,7 @@ namespace jank::read::parse`
`166`	`177`	`case lex::token_kind::escaped_string:`
`167`	`178`	`return parse_escaped_string();`
`168`	`179`	`case lex::token_kind::eof:`
`169`		`- return ok(nullptr);`
	`180`	`+ return ok(none);`
`170`	`181`	`default:`
`171`	`182`	`{`
`172`	`183`	`native_persistent_string msg{ fmt::format("unexpected token kind: {}",`
`@@ -191,15 +202,15 @@ namespace jank::read::parse`
`191`	`202`	`{`
`192`	`203`	`return err(it.latest.unwrap().expect_err());`
`193`	`204`	`}`
`194`		`- ret.push_back(it.latest.unwrap().expect_ok());`
	`205`	`+ ret.push_back(it.latest.unwrap().expect_ok().unwrap().ptr);`
`195`	`206`	`}`
`196`	`207`	`if(expected_closer.is_some())`
`197`	`208`	`{`
`198`	`209`	`return err(error{ start_token.pos, "Unterminated list" });`
`199`	`210`	`}`
`200`	`211`
`201`	`212`	`expected_closer = prev_expected_closer;`
`202`		`- return make_box<runtime::obj::persistent_list>(ret.rbegin(), ret.rend());`
	`213`	`+ return object_source_info{ make_box<runtime::obj::persistent_list>(ret.rbegin(), ret.rend()) };`
`203`	`214`	`}`
`204`	`215`
`205`	`216`	`processor::object_result processor::parse_vector()`
`@@ -216,15 +227,15 @@ namespace jank::read::parse`
`216`	`227`	`{`
`217`	`228`	`return err(it.latest.unwrap().expect_err());`
`218`	`229`	`}`
`219`		`- ret.push_back(it.latest.unwrap().expect_ok());`
	`230`	`+ ret.push_back(it.latest.unwrap().expect_ok().unwrap().ptr);`
`220`	`231`	`}`
`221`	`232`	`if(expected_closer.is_some())`
`222`	`233`	`{`
`223`	`234`	`return err(error{ start_token.pos, "Unterminated vector" });`
`224`	`235`	`}`
`225`	`236`
`226`	`237`	`expected_closer = prev_expected_closer;`
`227`		`- return make_box<runtime::obj::persistent_vector>(ret.persistent());`
	`238`	`+ return object_source_info{ make_box<runtime::obj::persistent_vector>(ret.persistent()) };`
`228`	`239`	`}`
`229`	`240`
`230`	`241`	`/* TODO: Uniqueness check. */`
`@@ -255,15 +266,15 @@ namespace jank::read::parse`
`255`	`266`	`}`
`256`	`267`	`auto const value(it.latest.unwrap().expect_ok());`
`257`	`268`
`258`		`- ret.insert_or_assign(key, value);`
	`269`	`+ ret.insert_or_assign(key.unwrap().ptr, value.unwrap().ptr);`
`259`	`270`	`}`
`260`	`271`	`if(expected_closer.is_some())`
`261`	`272`	`{`
`262`	`273`	`return err(error{ start_token.pos, "Unterminated map" });`
`263`	`274`	`}`
`264`	`275`
`265`	`276`	`expected_closer = prev_expected_closer;`
`266`		`- return make_box<runtime::obj::persistent_array_map>(ret);`
	`277`	`+ return object_source_info{ make_box<runtime::obj::persistent_array_map>(ret) };`
`267`	`278`	`}`
`268`	`279`
`269`	`280`	`processor::object_result processor::parse_quote()`
`@@ -278,28 +289,28 @@ namespace jank::read::parse`
`278`	`289`	`{`
`279`	`290`	`return val_result;`
`280`	`291`	`}`
`281`		`- else if(val_result.expect_ok() == nullptr)`
	`292`	`+ else if(val_result.expect_ok().is_none())`
`282`	`293`	`{`
`283`	`294`	`return err(error{ start_token.pos, native_persistent_string{ "invalid value after quote" } });`
`284`	`295`	`}`
`285`	`296`
`286`		`- return runtime::erase(`
	`297`	`+ return object_source_info{ runtime::erase(`
`287`	`298`	`make_box<runtime::obj::persistent_list>(make_box<runtime::obj::symbol>("quote"),`
`288`		`- val_result.expect_ok_move()));`
	`299`	`+ val_result.expect_ok().unwrap().ptr)) };`
`289`	`300`	`}`
`290`	`301`
`291`	`302`	`processor::object_result processor::parse_nil()`
`292`	`303`	`{`
`293`	`304`	`++token_current;`
`294`		`- return ok(runtime::obj::nil::nil_const());`
	`305`	`+ return object_source_info{ runtime::obj::nil::nil_const() };`
`295`	`306`	`}`
`296`	`307`
`297`	`308`	`processor::object_result processor::parse_boolean()`
`298`	`309`	`{`
`299`	`310`	`auto const token((*token_current).expect_ok());`
`300`	`311`	`++token_current;`
`301`	`312`	`auto const b(boost::get<native_bool>(token.data));`
`302`		`- return ok(make_box<runtime::obj::boolean>(b));`
	`313`	`+ return object_source_info{ make_box<runtime::obj::boolean>(b) };`
`303`	`314`	`}`
`304`	`315`
`305`	`316`	`processor::object_result processor::parse_symbol()`
`@@ -341,7 +352,7 @@ namespace jank::read::parse`
`341`	`352`	`{`
`342`	`353`	`name = sv;`
`343`	`354`	`}`
`344`		`- return ok(make_box<runtime::obj::symbol>(ns, name));`
	`355`	`+ return object_source_info{ make_box<runtime::obj::symbol>(ns, name) };`
`345`	`356`	`}`
`346`	`357`
`347`	`358`	`processor::object_result processor::parse_keyword()`
`@@ -377,30 +388,31 @@ namespace jank::read::parse`
`377`	`388`	`{`
`378`	`389`	`return err(intern_res.expect_err());`
`379`	`390`	`}`
`380`		`- return ok(intern_res.expect_ok());`
	`391`	`+ return object_source_info{ intern_res.expect_ok() };`
`381`	`392`	`}`
`382`	`393`
`383`	`394`	`processor::object_result processor::parse_integer()`
`384`	`395`	`{`
`385`	`396`	`auto const token(token_current->expect_ok());`
`386`	`397`	`++token_current;`
`387`		`- return ok(make_box<runtime::obj::integer>(boost::get<native_integer>(token.data)));`
	`398`	`+ return object_source_info{ make_box<runtime::obj::integer>(`
	`399`	`+ boost::get<native_integer>(token.data)) };`
`388`	`400`	`}`
`389`	`401`
`390`	`402`	`processor::object_result processor::parse_real()`
`391`	`403`	`{`
`392`	`404`	`auto const token(token_current->expect_ok());`
`393`	`405`	`++token_current;`
`394`		`- return ok(make_box<runtime::obj::real>(boost::get<native_real>(token.data)));`
	`406`	`+ return object_source_info{ make_box<runtime::obj::real>(boost::get<native_real>(token.data)) };`
`395`	`407`	`}`
`396`	`408`
`397`	`409`	`processor::object_result processor::parse_string()`
`398`	`410`	`{`
`399`	`411`	`auto const token(token_current->expect_ok());`
`400`	`412`	`++token_current;`
`401`	`413`	`auto const sv(boost::get<native_persistent_string_view>(token.data));`
`402`		`- return ok(`
`403`		`- make_box<runtime::obj::persistent_string>(native_persistent_string{ sv.data(), sv.size() }));`
	`414`	`+ return object_source_info{ make_box<runtime::obj::persistent_string>(`
	`415`	`+ native_persistent_string{ sv.data(), sv.size() }) };`
`404`	`416`	`}`
`405`	`417`
`406`	`418`	`processor::object_result processor::parse_escaped_string()`
`@@ -413,7 +425,7 @@ namespace jank::read::parse`
`413`	`425`	`{`
`414`	`426`	`return err(error{ token.pos, res.expect_err_move() });`
`415`	`427`	`}`
`416`		`- return ok(make_box<runtime::obj::persistent_string>(res.expect_ok_move()));`
	`428`	`+ return object_source_info{ make_box<runtime::obj::persistent_string>(res.expect_ok_move()) };`
`417`	`429`	`}`
`418`	`430`
`419`	`431`	`processor::iterator processor::begin()`
`@@ -423,6 +435,6 @@ namespace jank::read::parse`
`423`	`435`
`424`	`436`	`processor::iterator processor::end()`
`425`	`437`	`{`
`426`		`- return { some(ok(nullptr)), *this };`
	`438`	`+ return { some(ok(none)), *this };`
`427`	`439`	`}`
`428`	`440`	`}`
Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,8 @@ namespace jank::runtime`
`197`	`197`	`native_vector<analyze::expression_ptr> exprs{};`
`198`	`198`	`for(auto const &form : p_prc)`
`199`	`199`	`{`
`200`		`- auto const expr(an_prc.analyze(form.expect_ok(), analyze::expression_type::statement));`
	`200`	`+ auto const expr(`
	`201`	`+ an_prc.analyze(form.expect_ok().unwrap().ptr, analyze::expression_type::statement));`
`201`	`202`	`ret = evaluate::eval(*this, jit_prc, expr.expect_ok());`
`202`	`203`	`exprs.emplace_back(expr.expect_ok());`
`203`	`204`	`}`
`@@ -230,7 +231,8 @@ namespace jank::runtime`
`230`	`231`	`native_vector<analyze::expression_ptr> ret{};`
`231`	`232`	`for(auto const &form : p_prc)`
`232`	`233`	`{`
`233`		`- auto const expr(an_prc.analyze(form.expect_ok(), analyze::expression_type::statement));`
	`234`	`+ auto const expr(`
	`235`	`+ an_prc.analyze(form.expect_ok().unwrap().ptr, analyze::expression_type::statement));`
`234`	`236`	`if(eval)`
`235`	`237`	`{`
`236`	`238`	`evaluate::eval(*this, jit_prc, expr.expect_ok());`