Remove THeapObjectHolder, std::nullptr_t from variant

include/CrossLang.hpp

@@ -1357,13 +1357,6 @@ class THeapObject {
     virtual ~THeapObject() = default;
 };
 
-class THeapObjectHolder {
-  public:
-    THeapObject *obj;
-    THeapObjectHolder(THeapObject *obj) { this->obj = obj; }
-    THeapObjectHolder() {}
-};
-
 // this is a dummy type with
 class MethodInvoker {};
 
@@ -1377,7 +1370,7 @@ class TContinue {};
 using TObject =
     std::variant<Undefined, int64_t, double, char, bool, std::string,
                  std::regex, Tesses::Framework::Filesystem::VFSPath,
-                 std::nullptr_t, MethodInvoker, THeapObjectHolder, TVMVersion,
+                 MethodInvoker, THeapObject *, TVMVersion,
                  std::shared_ptr<Tesses::Framework::Date::DateTime>,
                  std::shared_ptr<Tesses::Framework::Date::TimeSpan>, TBreak,
                  TContinue, std::shared_ptr<Tesses::Framework::Streams::Stream>,
@@ -2578,6 +2571,22 @@ template <typename T> bool GetObject(TObject &obj, T &res) {
     res = std::get<T>(obj);
     return true;
 }
+
+inline bool IsNull(const TObject &obj) {
+    if (!std::holds_alternative<THeapObject *>(obj))
+        return false;
+
+    return std::get<THeapObject *>(obj) == nullptr;
+}
+
+[[deprecated("Use GetObjectHeap() with TString instead")]]
+inline bool GetObject(TObject &obj, std::string &str) {
+    if (!std::holds_alternative<std::string>(obj))
+        return false;
+    str = std::get<std::string>(obj);
+    return true;
+}
+
 template <typename T>
 bool GetArgument(std::vector<TObject> &args, size_t index, T &obj) {
     if (index >= args.size())
@@ -2586,10 +2595,10 @@ bool GetArgument(std::vector<TObject> &args, size_t index, T &obj) {
 }
 
 template <typename T> bool GetObjectHeap(TObject &obj, T &res) {
-    THeapObjectHolder h;
+    THeapObject *h;
-    if (!GetObject<THeapObjectHolder>(obj, h))
+    if (!GetObject<THeapObject *>(obj, h))
         return false;
-    auto v = dynamic_cast<T>(h.obj);
+    auto v = dynamic_cast<T>(h);
     if (v == nullptr)
         return false;
     res = v;

src/compiler/ast.cpp

@@ -75,7 +75,7 @@ SyntaxNode Deserialize(std::string astData) {
 }
 #if defined(CROSSLANG_ENABLE_JSON)
 static json_t *Serialize2(SyntaxNode node) {
-    if (std::holds_alternative<std::nullptr_t>(node))
+    if (IsNull(node))
         return json_null();
     if (std::holds_alternative<int64_t>(node)) {
         return json_integer(std::get<int64_t>(node));

src/compiler/parser.cpp

@@ -5,7 +5,7 @@ namespace Tesses::CrossLang {
 SyntaxNode TObject2SyntaxNode(TObject o) {
     if (std::holds_alternative<Undefined>(o))
         return Undefined();
-    if (std::holds_alternative<std::nullptr_t>(o))
+    if (IsNull(o))
         return nullptr;
     if (std::holds_alternative<std::string>(o))
         return std::get<std::string>(o);
@@ -491,9 +491,8 @@ void Parser::ParseHtml(std::vector<SyntaxNode> &nodes, std::string var) {
                 EnsureSymbol(">");
 
                 if (std::holds_alternative<std::nullptr_t>(item))
-                    item = AdvancedSyntaxNode::Create(
+                    item = AdvancedSyntaxNode::Create(DeclareExpression, true,
-                        DeclareExpression, true,
+                                                      {"item"});
-                        {"item"});
 
                 std::vector<SyntaxNode> _nodes;
                 parseFn(_nodes, "each");
@@ -1379,9 +1378,8 @@ SyntaxNode Parser::ParseNode(bool isRoot) {
             body = ParseNode();
         }
         if (std::holds_alternative<std::nullptr_t>(item))
-            item = AdvancedSyntaxNode::Create(
+            item =
-                DeclareExpression, true,
+                AdvancedSyntaxNode::Create(DeclareExpression, true, {"item"});
-                {"item"});
 
         return AdvancedSyntaxNode::Create(EachStatement, false,
                                           {item, list, body});

src/runtime_methods/json.cpp

@@ -5,7 +5,7 @@ using namespace Tesses::Framework::Serialization::Json;
 namespace Tesses::CrossLang {
 
 static bool IsValidForJson(TObject v) {
-    if (std::holds_alternative<std::nullptr_t>(v))
+    if (IsNull(v))
         return true;
 
     if (std::holds_alternative<int64_t>(v))
@@ -20,10 +20,10 @@ static bool IsValidForJson(TObject v) {
     if (std::holds_alternative<std::string>(v))
         return true;
 
-    if (std::holds_alternative<THeapObjectHolder>(v)) {
+    if (std::holds_alternative<THeapObject *>(v)) {
-        auto res = std::get<THeapObjectHolder>(v);
+        auto res = std::get<THeapObject *>(v);
-        auto ls = dynamic_cast<TList *>(res.obj);
+        auto ls = dynamic_cast<TList *>(res);
-        auto dict = dynamic_cast<TDictionary *>(res.obj);
+        auto dict = dynamic_cast<TDictionary *>(res);
         if (ls != nullptr)
             return true;
         if (dict != nullptr)
@@ -32,7 +32,7 @@ static bool IsValidForJson(TObject v) {
     return false;
 }
 static JToken JsonSerialize(TObject v) {
-    if (std::holds_alternative<std::nullptr_t>(v))
+    if (IsNull(v))
         return nullptr;
     if (std::holds_alternative<int64_t>(v))
         return std::get<int64_t>(v);
@@ -42,8 +42,8 @@ static JToken JsonSerialize(TObject v) {
         return std::get<bool>(v);
     if (std::holds_alternative<std::string>(v))
         return std::get<std::string>(v);
-    if (std::holds_alternative<THeapObjectHolder>(v)) {
+    if (std::holds_alternative<THeapObject *>(v)) {
-        auto obj = std::get<THeapObjectHolder>(v).obj;
+        auto obj = std::get<THeapObject *>(v);
         auto ls = dynamic_cast<TList *>(obj);
         auto dict = dynamic_cast<TDictionary *>(obj);
 

src/runtime_methods/std.cpp

@@ -143,8 +143,8 @@ ffi_tmp_type_t FFI_ConvertTObjectToFFIType(TObject &arg, std::string t) {
             return (ffi_tmp_type_t){
                 .v_ptr = (void *)std::get<std::string>(arg).c_str()};
         }
-    } else if (std::holds_alternative<THeapObjectHolder>(arg)) {
+    } else if (std::holds_alternative<THeapObject *>(arg)) {
-        auto obj = std::get<THeapObjectHolder>(arg).obj;
+        auto obj = std::get<THeapObject *>(arg);
         auto bA = dynamic_cast<TByteArray *>(obj);
         auto nat = dynamic_cast<TNative *>(obj);
         if (bA != nullptr) {
@@ -435,13 +435,7 @@ static TObject TypeIsClass(GCList &ls, std::vector<TObject> args) {
 static TObject TypeIsDefined(GCList &ls, std::vector<TObject> args) {
     if (args.empty())
         return nullptr;
-    return (!std::holds_alternative<std::nullptr_t>(args[0]) &&
+    return (!IsNull(args[0]) && !std::holds_alternative<Undefined>(args[0]));
-            !std::holds_alternative<Undefined>(args[0]));
-}
-static TObject TypeIsHeap(GCList &ls, std::vector<TObject> args) {
-    if (args.empty())
-        return nullptr;
-    return std::holds_alternative<THeapObjectHolder>(args[0]);
 }
 static TObject TypeIsNumber(GCList &ls, std::vector<TObject> args) {
     if (args.empty())
@@ -668,7 +662,7 @@ std::string GetObjectTypeString(TObject _obj) {
         return "Regex";
     if (std::holds_alternative<Undefined>(_obj))
         return "Undefined";
-    if (std::holds_alternative<std::nullptr_t>(_obj))
+    if (IsNull(_obj))
         return "Null";
     if (std::holds_alternative<bool>(_obj))
         return "Boolean";
@@ -820,8 +814,8 @@ std::string GetObjectTypeString(TObject _obj) {
         }
         return "VFS";
     }
-    if (std::holds_alternative<THeapObjectHolder>(_obj)) {
+    if (std::holds_alternative<THeapObject *>(_obj)) {
-        auto obj = std::get<THeapObjectHolder>(_obj).obj;
+        auto obj = std::get<THeapObject *>(_obj);
         auto dict = dynamic_cast<TDictionary *>(obj);
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
 
@@ -1380,10 +1374,7 @@ void TStd::RegisterRoot(std::shared_ptr<GC> gc, TRootEnvironment *env) {
     env->DeclareFunction(gc, "TypeIsDefined",
                          "Get whether object is not null or undefined",
                          {"object"}, TypeIsDefined);
-    env->DeclareFunction(
+
-        gc, "TypeIsHeap",
-        "Get whether object is susceptible to garbage collection", {"object"},
-        TypeIsHeap);
     env->DeclareFunction(gc, "TypeIsNumber", "Get whether object is a number",
                          {"object"}, TypeIsNumber);
     env->DeclareFunction(gc, "TypeIsLong",
@@ -1455,9 +1446,9 @@ void TStd::RegisterRoot(std::shared_ptr<GC> gc, TRootEnvironment *env) {
         gc, "Thread", "Create thread", {"callback"},
         [](GCList &ls, std::vector<TObject> args) -> TObject {
             if (args.size() == 1 &&
-                std::holds_alternative<THeapObjectHolder>(args[0])) {
+                std::holds_alternative<THeapObject *>(args[0])) {
-                auto cb = dynamic_cast<TCallable *>(
+                auto cb =
-                    std::get<THeapObjectHolder>(args[0]).obj);
+                    dynamic_cast<TCallable *>(std::get<THeapObject *>(args[0]));
                 if (cb != nullptr) {
                     return CreateThread(ls, cb, false);
                 }

src/types/native.cpp

@@ -26,8 +26,8 @@ void TNative::Destroy() {
 }
 bool TNativeObject::ToBool() { return true; }
 bool TNativeObject::Equals(std::shared_ptr<GC> gc, TObject right) {
-    if (std::holds_alternative<THeapObjectHolder>(right)) {
+    if (std::holds_alternative<THeapObject *>(right)) {
-        return this == std::get<THeapObjectHolder>(right).obj;
+        return this == std::get<THeapObject *>(right);
     }
     return false;
 }

src/types/rootenvironment.cpp

@@ -171,9 +171,8 @@ void TEnvironment::DeclareVariable(std::shared_ptr<GC> gc,
 
         TObject v = this->GetVariable(name[0]);
         TDictionary *dict = nullptr;
-        if (std::holds_alternative<THeapObjectHolder>(v)) {
+        if (std::holds_alternative<THeapObject *>(v)) {
-            dict =
+            dict = dynamic_cast<TDictionary *>(std::get<THeapObject *>(v));
-                dynamic_cast<TDictionary *>(std::get<THeapObjectHolder>(v).obj);
             if (dict == nullptr) {
                 dict = TDictionary::Create(ls);
                 gc->BarrierBegin();
@@ -191,9 +190,9 @@ void TEnvironment::DeclareVariable(std::shared_ptr<GC> gc,
             gc->BarrierBegin();
             auto v = dict->GetValue(name[i]);
             gc->BarrierEnd();
-            if (std::holds_alternative<THeapObjectHolder>(v)) {
+            if (std::holds_alternative<THeapObject *>(v)) {
-                auto dict2 = dynamic_cast<TDictionary *>(
+                auto dict2 =
-                    std::get<THeapObjectHolder>(v).obj);
+                    dynamic_cast<TDictionary *>(std::get<THeapObject *>(v));
                 if (dict2 == nullptr) {
                     dict2 = TDictionary::Create(ls);
                     gc->BarrierBegin();

src/vm/bc/add.cpp

@@ -119,8 +119,8 @@ bool InterperterThread::Add(std::shared_ptr<GC> gc) {
         str.append(std::get<std::string>(left));
         str.push_back(std::get<char>(right));
         cse.back()->Push(gc, str);
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
         auto natObj = dynamic_cast<TNativeObject *>(obj);

src/vm/bc/equals.cpp

@@ -14,8 +14,7 @@ namespace Tesses::CrossLang {
 
 bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right) {
     GCList ls(gc);
-    if (std::holds_alternative<std::nullptr_t>(left) &&
+    if (IsNull(left) && IsNull(right)) {
-        std::holds_alternative<std::nullptr_t>(right)) {
 
         return true;
     }
@@ -92,8 +91,8 @@ bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right) {
         auto r = std::get<Tesses::Framework::Uuid>(right);
 
         return l == r;
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -109,12 +108,12 @@ bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right) {
             if (GetObjectHeap(obj, callable)) {
                 return ToBool(callable->Call(ls, {right}));
 
-            } else if (std::holds_alternative<std::nullptr_t>(right)) {
+            } else if (IsNull(right)) {
                 return false;
             } else if (std::holds_alternative<Undefined>(right)) {
                 return false;
-            } else if (std::holds_alternative<THeapObjectHolder>(right)) {
+            } else if (std::holds_alternative<THeapObject *>(right)) {
-                return cls == std::get<THeapObjectHolder>(right).obj;
+                return cls == std::get<THeapObject *>(right);
             }
         } else if (natObj != nullptr) {
             return natObj->Equals(gc, right);
@@ -124,10 +123,10 @@ bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right) {
             TObject fn = dict->GetValue("operator==");
             gc->BarrierEnd();
             if (!std::holds_alternative<Undefined>(fn)) {
-                if (std::holds_alternative<THeapObjectHolder>(fn)) {
+                if (std::holds_alternative<THeapObject *>(fn)) {
 
-                    auto obj = dynamic_cast<TCallable *>(
+                    auto obj =
-                        std::get<THeapObjectHolder>(fn).obj);
+                        dynamic_cast<TCallable *>(std::get<THeapObject *>(fn));
                     if (obj != nullptr) {
                         auto closure = dynamic_cast<TClosure *>(obj);
                         if (closure != nullptr) {
@@ -144,17 +143,17 @@ bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right) {
                         }
                     } else {
 
-                        return dict == std::get<THeapObjectHolder>(right).obj;
+                        return dict == std::get<THeapObject *>(right);
                     }
 
                 } else {
 
-                    return dict == std::get<THeapObjectHolder>(right).obj;
+                    return dict == std::get<THeapObject *>(right);
                 }
 
             } else {
 
-                return dict == std::get<THeapObjectHolder>(right).obj;
+                return dict == std::get<THeapObject *>(right);
             }
             return false;
 
@@ -162,21 +161,19 @@ bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right) {
 
         else if (dynDict != nullptr) {
             auto res = dynDict->CallMethod(ls, "operator==", {right});
-            if (!std::holds_alternative<std::nullptr_t>(res) &&
+            if (!IsNull(res) && std::holds_alternative<Undefined>(res)) {
-                std::holds_alternative<Undefined>(res)) {
                 return ToBool(res);
             }
-        } else if (native != nullptr &&
+        } else if (native != nullptr && IsNull(right)) {
-                   std::holds_alternative<std::nullptr_t>(right)) {
             return native->GetDestroyed();
         }
 
-        if (std::holds_alternative<THeapObjectHolder>(right)) {
+        if (std::holds_alternative<THeapObject *>(right)) {
-            return obj == std::get<THeapObjectHolder>(right).obj;
+            return obj == std::get<THeapObject *>(right);
 
         }
 
-        else if (std::holds_alternative<std::nullptr_t>(right)) {
+        else if (IsNull(right)) {
             return false;
         } else if (std::holds_alternative<Undefined>(right)) {
 
@@ -187,7 +184,7 @@ bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right) {
 
     }
 
-    else if (std::holds_alternative<std::nullptr_t>(right)) {
+    else if (IsNull(right)) {
         return false;
     } else if (std::holds_alternative<Undefined>(right)) {
         return false;

src/vm/bc/executemethod2.cpp

@@ -24,7 +24,7 @@ bool InterperterThread::ExecuteMethod2(std::shared_ptr<GC> gc, TObject instance,
         GCList ls(gc);
         std::regex regex;
         TVMVersion version;
-        if (std::holds_alternative<std::nullptr_t>(instance)) {
+        if (IsNull(instance)) {
             if (key == "ToString") {
                 cse.back()->Push(gc, "null");
                 return false;
@@ -1964,8 +1964,8 @@ bool InterperterThread::ExecuteMethod2(std::shared_ptr<GC> gc, TObject instance,
             }
             cse.back()->Push(gc, Undefined());
             return false;
-        } else if (std::holds_alternative<THeapObjectHolder>(instance)) {
+        } else if (std::holds_alternative<THeapObject *>(instance)) {
-            auto obj = std::get<THeapObjectHolder>(instance).obj;
+            auto obj = std::get<THeapObject *>(instance);
             auto list = dynamic_cast<TList *>(obj);
             auto dynList = dynamic_cast<TDynamicList *>(obj);
             auto bArray = dynamic_cast<TByteArray *>(obj);

src/vm/bc/getfield.cpp

@@ -323,8 +323,8 @@ bool InterperterThread::GetField(std::shared_ptr<GC> gc) {
             stk->Push(gc, Undefined());
             return false;
         }
-        if (std::holds_alternative<THeapObjectHolder>(instance)) {
+        if (std::holds_alternative<THeapObject *>(instance)) {
-            auto obj = std::get<THeapObjectHolder>(instance).obj;
+            auto obj = std::get<THeapObject *>(instance);
             auto bA = dynamic_cast<TByteArray *>(obj);
             auto list = dynamic_cast<TList *>(obj);
             auto dict = dynamic_cast<TDictionary *>(obj);
@@ -669,9 +669,9 @@ bool InterperterThread::GetField(std::shared_ptr<GC> gc) {
                 gc->BarrierBegin();
                 TObject fn = dict->GetValue("get" + key);
                 gc->BarrierEnd();
-                if (std::holds_alternative<THeapObjectHolder>(fn) &&
+                if (std::holds_alternative<THeapObject *>(fn) &&
-                    dynamic_cast<TCallable *>(
+                    dynamic_cast<TCallable *>(std::get<THeapObject *>(fn)) !=
-                        std::get<THeapObjectHolder>(fn).obj) != nullptr) {
+                        nullptr) {
                     return InvokeOne(ls, fn, dict);
                 } else {
                     gc->BarrierBegin();

src/vm/bc/invokemethod.cpp

@@ -15,10 +15,9 @@ namespace Tesses::CrossLang {
 bool InterperterThread::InvokeMethod(GCList &ls, TObject fn, TObject instance,
                                      std::vector<TObject> args) {
 
-    if (std::holds_alternative<THeapObjectHolder>(fn)) {
+    if (std::holds_alternative<THeapObject *>(fn)) {
 
-        auto obj =
+        auto obj = dynamic_cast<TCallable *>(std::get<THeapObject *>(fn));
-            dynamic_cast<TCallable *>(std::get<THeapObjectHolder>(fn).obj);
         if (obj != nullptr) {
             auto closure = dynamic_cast<TClosure *>(obj);
             if (closure != nullptr) {

src/vm/bc/invoketwo.cpp

@@ -12,10 +12,9 @@
 namespace Tesses::CrossLang {
 bool InterperterThread::InvokeTwo(GCList &ls, TObject fn, TObject left,
                                   TObject right) {
-    if (std::holds_alternative<THeapObjectHolder>(fn)) {
+    if (std::holds_alternative<THeapObject *>(fn)) {
 
-        auto obj =
+        auto obj = dynamic_cast<TCallable *>(std::get<THeapObject *>(fn));
-            dynamic_cast<TCallable *>(std::get<THeapObjectHolder>(fn).obj);
         if (obj != nullptr) {
             auto closure = dynamic_cast<TClosure *>(obj);
             if (closure != nullptr) {

src/vm/bc/setfield.cpp

@@ -257,8 +257,8 @@ bool InterperterThread::SetField(std::shared_ptr<GC> gc) {
             stk->Push(gc, Undefined());
             return false;
         }
-        if (std::holds_alternative<THeapObjectHolder>(instance)) {
+        if (std::holds_alternative<THeapObject *>(instance)) {
-            auto obj = std::get<THeapObjectHolder>(instance).obj;
+            auto obj = std::get<THeapObject *>(instance);
 
             auto dict = dynamic_cast<TDictionary *>(obj);
             auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -313,9 +313,9 @@ bool InterperterThread::SetField(std::shared_ptr<GC> gc) {
                 gc->BarrierBegin();
                 TObject fn = dict->GetValue("set" + key);
                 gc->BarrierEnd();
-                if (std::holds_alternative<THeapObjectHolder>(fn) &&
+                if (std::holds_alternative<THeapObject *>(fn) &&
-                    dynamic_cast<TCallable *>(
+                    dynamic_cast<TCallable *>(std::get<THeapObject *>(fn)) !=
-                        std::get<THeapObjectHolder>(fn).obj) != nullptr) {
+                        nullptr) {
                     return InvokeTwo(ls, fn, dict, value);
                 } else {
                     gc->BarrierBegin();

src/vm/bc/sub.cpp

@@ -65,8 +65,8 @@ bool InterperterThread::Sub(std::shared_ptr<GC> gc) {
         cse.back()->Push(
             gc,
             std::make_shared<Tesses::Framework::Date::DateTime>((*l) - (*r)));
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
 

src/vm/bc/tobool.cpp

@@ -44,8 +44,8 @@ bool ToBool(TObject obj) {
     } else if (std::holds_alternative<Tesses::Framework::Uuid>(obj)) {
         auto &uuid = std::get<Tesses::Framework::Uuid>(obj);
         return !uuid.IsEmpty();
-    } else if (std::holds_alternative<THeapObjectHolder>(obj)) {
+    } else if (std::holds_alternative<THeapObject *>(obj)) {
-        auto o = std::get<THeapObjectHolder>(obj).obj;
+        auto o = std::get<THeapObject *>(obj);
         auto ls = dynamic_cast<TList *>(o);
         auto aarray = dynamic_cast<TAssociativeArray *>(o);
         auto dict = dynamic_cast<TDictionary *>(o);

src/vm/bc/tostring.cpp

@@ -31,7 +31,7 @@ std::string ToString(std::shared_ptr<GC> gc, TObject o) {
     if (std::holds_alternative<char>(o)) {
         return std::string{std::get<char>(o)};
     }
-    if (std::holds_alternative<std::nullptr_t>(o)) {
+    if (IsNull(o)) {
         return "null";
     }
     if (std::holds_alternative<Undefined>(o)) {
@@ -54,8 +54,8 @@ std::string ToString(std::shared_ptr<GC> gc, TObject o) {
         return std::get<Tesses::Framework::Uuid>(o).ToString(
             Framework::UuidStringifyConfig::LowercaseNoCurly);
     }
-    if (std::holds_alternative<THeapObjectHolder>(o)) {
+    if (std::holds_alternative<THeapObject *>(o)) {
-        auto obj = std::get<THeapObjectHolder>(o).obj;
+        auto obj = std::get<THeapObject *>(o);
         auto dict = dynamic_cast<TDictionary *>(obj);
         auto list = dynamic_cast<TList *>(obj);
         auto bArray = dynamic_cast<TByteArray *>(obj);

src/vm/gc.cpp

@@ -140,8 +140,8 @@ bool GC::UsingNullThreads() { return false; }
 void GC::BarrierBegin() { this->mtx.Lock(); }
 void GC::BarrierEnd() { this->mtx.Unlock(); }
 void GC::Watch(TObject obj) {
-    if (std::holds_alternative<THeapObjectHolder>(obj)) {
+    if (std::holds_alternative<THeapObject *>(obj)) {
-        auto _item = std::get<THeapObjectHolder>(obj).obj;
+        auto _item = std::get<THeapObject *>(obj);
         this->BarrierBegin();
         this->objects.insert(_item);
         auto nowAllocs = ++this->allocs;
@@ -151,14 +151,14 @@ void GC::Watch(TObject obj) {
     }
 }
 void GC::Mark(TObject obj) {
-    if (std::holds_alternative<THeapObjectHolder>(obj)) {
+    if (std::holds_alternative<THeapObject *>(obj)) {
-        auto _item = std::get<THeapObjectHolder>(obj).obj;
+        auto _item = std::get<THeapObject *>(obj);
         _item->Mark();
     }
 }
 void GC::Unwatch(TObject obj) {
-    if (std::holds_alternative<THeapObjectHolder>(obj)) {
+    if (std::holds_alternative<THeapObject *>(obj)) {
-        auto _item = std::get<THeapObjectHolder>(obj).obj;
+        auto _item = std::get<THeapObject *>(obj);
         this->BarrierBegin();
         this->objects.erase(_item);
         this->BarrierEnd();

src/vm/gclist.cpp

@@ -10,8 +10,8 @@ GCList::GCList(std::shared_ptr<GC> gc) {
 
 std::shared_ptr<GC> GCList::GetGC() const { return this->gc; }
 void GCList::Remove(TObject obj) {
-    if (std::holds_alternative<THeapObjectHolder>(obj)) {
+    if (std::holds_alternative<THeapObject *>(obj)) {
-        auto _item = std::get<THeapObjectHolder>(obj).obj;
+        auto _item = std::get<THeapObject *>(obj);
         this->gc->BarrierBegin();
         for (auto index = this->items.begin(); index != this->items.end();
              index++) {
@@ -25,8 +25,8 @@ void GCList::Remove(TObject obj) {
 }
 void GCList::Add(TObject obj) {
 
-    if (std::holds_alternative<THeapObjectHolder>(obj)) {
+    if (std::holds_alternative<THeapObject *>(obj)) {
-        auto _item = std::get<THeapObjectHolder>(obj).obj;
+        auto _item = std::get<THeapObject *>(obj);
         this->gc->BarrierBegin();
 
         for (auto item : this->items) {

src/vm/vm.cpp

@@ -79,8 +79,8 @@ bool InterperterThread::Times(std::shared_ptr<GC> gc) {
     } else if (std::holds_alternative<int64_t>(left) &&
                std::holds_alternative<double>(right)) {
         cse.back()->Push(gc, std::get<int64_t>(left) * std::get<double>(right));
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -180,8 +180,8 @@ bool InterperterThread::Divide(std::shared_ptr<GC> gc) {
         cse.back()->Push(gc, std::get<int64_t>(left) / std::get<double>(right));
     }
 
-    else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -256,8 +256,8 @@ bool InterperterThread::Mod(std::shared_ptr<GC> gc) {
             gc, fmod(std::get<int64_t>(left), std::get<double>(right)));
     }
 
-    else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -312,8 +312,8 @@ bool InterperterThread::Neg(std::shared_ptr<GC> gc) {
         cse.back()->Push(gc, -std::get<int64_t>(left));
     } else if (std::holds_alternative<double>(left)) {
         cse.back()->Push(gc, -std::get<double>(left));
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
 
@@ -365,7 +365,7 @@ bool InterperterThread::LNot(std::shared_ptr<GC> gc) {
 
     if (std::holds_alternative<Undefined>(left)) {
         cse.back()->Push(gc, true);
-    } else if (std::holds_alternative<std::nullptr_t>(left)) {
+    } else if (IsNull(left)) {
         cse.back()->Push(gc, true);
     }
 
@@ -375,8 +375,8 @@ bool InterperterThread::LNot(std::shared_ptr<GC> gc) {
 
     else if (std::holds_alternative<bool>(left)) {
         cse.back()->Push(gc, !std::get<bool>(left));
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -431,8 +431,8 @@ bool InterperterThread::BNot(std::shared_ptr<GC> gc) {
         cse.back()->Push(gc, ~std::get<int64_t>(left));
     }
 
-    else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -538,8 +538,8 @@ bool InterperterThread::Lt(std::shared_ptr<GC> gc) {
         auto &r =
             std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
         cse.back()->Push(gc, l->TotalSeconds() < r->TotalSeconds());
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -644,8 +644,8 @@ bool InterperterThread::Gt(std::shared_ptr<GC> gc) {
         auto &r =
             std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
         cse.back()->Push(gc, l->TotalSeconds() > r->TotalSeconds());
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -751,8 +751,8 @@ bool InterperterThread::Lte(std::shared_ptr<GC> gc) {
         auto &r =
             std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
         cse.back()->Push(gc, l->TotalSeconds() <= r->TotalSeconds());
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -863,8 +863,8 @@ bool InterperterThread::Gte(std::shared_ptr<GC> gc) {
         auto &r =
             std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
         cse.back()->Push(gc, l->TotalSeconds() >= r->TotalSeconds());
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -917,8 +917,7 @@ bool InterperterThread::Eq(std::shared_ptr<GC> gc) {
     GCList ls(gc);
     auto right = cse.back()->Pop(ls);
     auto left = cse.back()->Pop(ls);
-    if (std::holds_alternative<std::nullptr_t>(left) &&
+    if (IsNull(left) && IsNull(right)) {
-        std::holds_alternative<std::nullptr_t>(right)) {
         cse.back()->Push(gc, true);
         return false;
     }
@@ -1000,8 +999,8 @@ bool InterperterThread::Eq(std::shared_ptr<GC> gc) {
         auto &r =
             std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
         cse.back()->Push(gc, l->TotalSeconds() == r->TotalSeconds());
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -1039,25 +1038,23 @@ bool InterperterThread::Eq(std::shared_ptr<GC> gc) {
 
         else if (dynDict != nullptr) {
             auto res = dynDict->CallMethod(ls, "operator==", {right});
-            if (!std::holds_alternative<std::nullptr_t>(res) &&
+            if (!IsNull(res) && std::holds_alternative<Undefined>(res)) {
-                std::holds_alternative<Undefined>(res)) {
                 cse.back()->Push(gc, res);
                 return false;
             }
         }
 
-        else if (native != nullptr &&
+        else if (native != nullptr && IsNull(right)) {
-                 std::holds_alternative<std::nullptr_t>(right)) {
             cse.back()->Push(gc, native->GetDestroyed());
             return false;
         }
 
-        if (std::holds_alternative<THeapObjectHolder>(right)) {
+        if (std::holds_alternative<THeapObject *>(right)) {
-            cse.back()->Push(gc, obj == std::get<THeapObjectHolder>(right).obj);
+            cse.back()->Push(gc, obj == std::get<THeapObject *>(right));
             return false;
         }
 
-        else if (std::holds_alternative<std::nullptr_t>(right)) {
+        else if (IsNull(right)) {
             cse.back()->Push(gc, false);
             return false;
         } else if (std::holds_alternative<Undefined>(right)) {
@@ -1069,7 +1066,7 @@ bool InterperterThread::Eq(std::shared_ptr<GC> gc) {
 
     }
 
-    else if (std::holds_alternative<std::nullptr_t>(right)) {
+    else if (IsNull(right)) {
         cse.back()->Push(gc, false);
         return false;
     } else if (std::holds_alternative<Undefined>(right)) {
@@ -1087,8 +1084,7 @@ bool InterperterThread::NEq(std::shared_ptr<GC> gc) {
     auto right = cse.back()->Pop(ls);
     auto left = cse.back()->Pop(ls);
 
-    if (std::holds_alternative<std::nullptr_t>(left) &&
+    if (IsNull(left) && IsNull(right)) {
-        std::holds_alternative<std::nullptr_t>(right)) {
         cse.back()->Push(gc, false);
         return false;
     } else if (std::holds_alternative<Undefined>(left) &&
@@ -1158,8 +1154,8 @@ bool InterperterThread::NEq(std::shared_ptr<GC> gc) {
         auto &r =
             std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
         cse.back()->Push(gc, l->TotalSeconds() != r->TotalSeconds());
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
         auto native = dynamic_cast<TNative *>(obj);
         auto natObj = dynamic_cast<TNativeObject *>(obj);
@@ -1196,22 +1192,20 @@ bool InterperterThread::NEq(std::shared_ptr<GC> gc) {
         else if (dynDict != nullptr) {
 
             auto res = dynDict->CallMethod(ls, "operator!=", {right});
-            if (!std::holds_alternative<std::nullptr_t>(res) &&
+            if (!IsNull(res) && std::holds_alternative<Undefined>(res)) {
-                std::holds_alternative<Undefined>(res)) {
                 cse.back()->Push(gc, res);
                 return false;
             }
         }
 
-        else if (native != nullptr &&
+        else if (native != nullptr && IsNull(right)) {
-                 std::holds_alternative<std::nullptr_t>(right)) {
             cse.back()->Push(gc, !native->GetDestroyed());
             return false;
         }
-        if (std::holds_alternative<THeapObjectHolder>(right)) {
+        if (std::holds_alternative<THeapObject *>(right)) {
-            cse.back()->Push(gc, obj != std::get<THeapObjectHolder>(right).obj);
+            cse.back()->Push(gc, obj != std::get<THeapObject *>(right));
             return false;
-        } else if (std::holds_alternative<std::nullptr_t>(right)) {
+        } else if (IsNull(right)) {
             cse.back()->Push(gc, true);
             return false;
         } else if (std::holds_alternative<Undefined>(right)) {
@@ -1224,7 +1218,7 @@ bool InterperterThread::NEq(std::shared_ptr<GC> gc) {
     } else if (std::holds_alternative<Undefined>(right)) {
         cse.back()->Push(gc, true);
         return false;
-    } else if (std::holds_alternative<std::nullptr_t>(right)) {
+    } else if (IsNull(right)) {
         cse.back()->Push(gc, true);
         return false;
     } else {
@@ -1243,8 +1237,8 @@ bool InterperterThread::LShift(std::shared_ptr<GC> gc) {
         std::holds_alternative<int64_t>(right)) {
         cse.back()->Push(gc, std::get<int64_t>(left)
                                  << (int)std::get<int64_t>(right));
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -1301,8 +1295,8 @@ bool InterperterThread::RShift(std::shared_ptr<GC> gc) {
         std::holds_alternative<int64_t>(right)) {
         cse.back()->Push(gc, std::get<int64_t>(left) >>
                                  (int)std::get<int64_t>(right));
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -1359,8 +1353,8 @@ bool InterperterThread::BOr(std::shared_ptr<GC> gc) {
         std::holds_alternative<int64_t>(right)) {
         cse.back()->Push(gc,
                          std::get<int64_t>(left) | std::get<int64_t>(right));
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -1417,8 +1411,8 @@ bool InterperterThread::XOr(std::shared_ptr<GC> gc) {
         std::holds_alternative<int64_t>(right)) {
         cse.back()->Push(gc,
                          std::get<int64_t>(left) ^ std::get<int64_t>(right));
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -1474,8 +1468,8 @@ bool InterperterThread::BAnd(std::shared_ptr<GC> gc) {
         std::holds_alternative<int64_t>(right)) {
         cse.back()->Push(gc,
                          std::get<int64_t>(left) & std::get<int64_t>(right));
-    } else if (std::holds_alternative<THeapObjectHolder>(left)) {
+    } else if (std::holds_alternative<THeapObject *>(left)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+        auto obj = std::get<THeapObject *>(left);
         auto dict = dynamic_cast<TDictionary *>(obj);
 
         auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
@@ -1520,10 +1514,9 @@ bool InterperterThread::BAnd(std::shared_ptr<GC> gc) {
     return false;
 }
 bool InterperterThread::InvokeOne(GCList &ls, TObject fn, TObject arg) {
-    if (std::holds_alternative<THeapObjectHolder>(fn)) {
+    if (std::holds_alternative<THeapObject *>(fn)) {
 
-        auto obj =
+        auto obj = dynamic_cast<TCallable *>(std::get<THeapObject *>(fn));
-            dynamic_cast<TCallable *>(std::get<THeapObjectHolder>(fn).obj);
         if (obj != nullptr) {
             auto closure = dynamic_cast<TClosure *>(obj);
             if (closure != nullptr) {
@@ -1568,10 +1561,10 @@ bool InterperterThread::ExecuteFunction(std::shared_ptr<GC> gc) {
                 if (args.size() == 3) {
 
                     if (std::holds_alternative<std::string>(args[1]) &&
-                        std::holds_alternative<THeapObjectHolder>(args[2])) {
+                        std::holds_alternative<THeapObject *>(args[2])) {
                         std::string key = std::get<std::string>(args[1]);
                         TList *ls = dynamic_cast<TList *>(
-                            std::get<THeapObjectHolder>(args[2]).obj);
+                            std::get<THeapObject *>(args[2]));
                         if (ls != nullptr)
                             return ExecuteMethod2(gc, args[0], key, ls->items);
                     }
@@ -1580,10 +1573,10 @@ bool InterperterThread::ExecuteFunction(std::shared_ptr<GC> gc) {
                 return false;
             }
 
-            if (std::holds_alternative<THeapObjectHolder>(fn)) {
+            if (std::holds_alternative<THeapObject *>(fn)) {
 
-                auto obj = dynamic_cast<TCallable *>(
+                auto obj =
-                    std::get<THeapObjectHolder>(fn).obj);
+                    dynamic_cast<TCallable *>(std::get<THeapObject *>(fn));
                 if (obj != nullptr) {
                     auto closure = dynamic_cast<TClosure *>(obj);
                     if (closure != nullptr) {
@@ -2147,8 +2140,7 @@ bool InterperterThread::JumpIfDefined(std::shared_ptr<GC> gc) {
         auto _res2 = stk->Pop(ls);
 
         stk->ip = stk->ip + 4;
-        if (!std::holds_alternative<Undefined>(_res2) &&
+        if (!std::holds_alternative<Undefined>(_res2) && !IsNull(_res2)) {
-            !std::holds_alternative<std::nullptr_t>(_res2)) {
             stk->ip = n;
             stk->Push(gc, _res2);
         }
@@ -2321,9 +2313,8 @@ bool InterperterThread::AppendList(std::shared_ptr<GC> gc) {
     gc->BarrierBegin();
     auto obj = stk->Pop(ls);
     auto objhold = stk->Pop(ls);
-    if (std::holds_alternative<THeapObjectHolder>(objhold)) {
+    if (std::holds_alternative<THeapObject *>(objhold)) {
-        auto list =
+        auto list = dynamic_cast<TList *>(std::get<THeapObject *>(objhold));
-            dynamic_cast<TList *>(std::get<THeapObjectHolder>(objhold).obj);
         if (list != nullptr) {
             list->Add(obj);
         }
@@ -2353,12 +2344,12 @@ bool InterperterThread::AppendDictionary(std::shared_ptr<GC> gc) {
     auto value = stk->Pop(ls);
     auto k = stk->Pop(ls);
     auto objhold = stk->Pop(ls);
-    if (std::holds_alternative<THeapObjectHolder>(objhold) &&
+    if (std::holds_alternative<THeapObject *>(objhold) &&
         std::holds_alternative<std::string>(k)) {
-        auto dict = dynamic_cast<TDictionary *>(
+        auto dict =
-            std::get<THeapObjectHolder>(objhold).obj);
+            dynamic_cast<TDictionary *>(std::get<THeapObject *>(objhold));
-        auto cls = dynamic_cast<TClassObject *>(
+        auto cls =
-            std::get<THeapObjectHolder>(objhold).obj);
+            dynamic_cast<TClassObject *>(std::get<THeapObject *>(objhold));
 
         if (dict != nullptr) {
             dict->SetValue(std::get<std::string>(k), value);