Remove THeapObjectHolder, std::nullptr_t from variant

2026-09-10 07:21:04 -05:00
parent 4aab28411a
commit 175afbafeb
20 changed files with 169 additions and 186 deletions
--- a/include/CrossLang.hpp
+++ b/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;
-    if (!GetObject<THeapObjectHolder>(obj, h))
+    THeapObject *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;
--- a/src/compiler/ast.cpp
+++ b/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));
--- a/src/compiler/parser.cpp
+++ b/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(
-                        DeclareExpression, true,
-                        {"item"});
+                    item = AdvancedSyntaxNode::Create(DeclareExpression, true,
+                                                      {"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(
-                DeclareExpression, true,
-                {"item"});
+            item =
+                AdvancedSyntaxNode::Create(DeclareExpression, true, {"item"});

        return AdvancedSyntaxNode::Create(EachStatement, false,
                                          {item, list, body});
--- a/src/runtime_methods/json.cpp
+++ b/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)) {
-        auto res = std::get<THeapObjectHolder>(v);
-        auto ls = dynamic_cast<TList *>(res.obj);
-        auto dict = dynamic_cast<TDictionary *>(res.obj);
+    if (std::holds_alternative<THeapObject *>(v)) {
+        auto res = std::get<THeapObject *>(v);
+        auto ls = dynamic_cast<TList *>(res);
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(v).obj;
+    if (std::holds_alternative<THeapObject *>(v)) {
+        auto obj = std::get<THeapObject *>(v);
        auto ls = dynamic_cast<TList *>(obj);
        auto dict = dynamic_cast<TDictionary *>(obj);

--- a/src/runtime_methods/std.cpp
+++ b/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)) {
-        auto obj = std::get<THeapObjectHolder>(arg).obj;
+    } else if (std::holds_alternative<THeapObject *>(arg)) {
+        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]) &&
-            !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]);
+    return (!IsNull(args[0]) && !std::holds_alternative<Undefined>(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)) {
-        auto obj = std::get<THeapObjectHolder>(_obj).obj;
+    if (std::holds_alternative<THeapObject *>(_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])) {
-                auto cb = dynamic_cast<TCallable *>(
-                    std::get<THeapObjectHolder>(args[0]).obj);
+                std::holds_alternative<THeapObject *>(args[0])) {
+                auto cb =
+                    dynamic_cast<TCallable *>(std::get<THeapObject *>(args[0]));
                if (cb != nullptr) {
                    return CreateThread(ls, cb, false);
                }
--- a/src/types/native.cpp
+++ b/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)) {
-        return this == std::get<THeapObjectHolder>(right).obj;
+    if (std::holds_alternative<THeapObject *>(right)) {
+        return this == std::get<THeapObject *>(right);
    }
    return false;
 }
--- a/src/types/rootenvironment.cpp
+++ b/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)) {
-            dict =
-                dynamic_cast<TDictionary *>(std::get<THeapObjectHolder>(v).obj);
+        if (std::holds_alternative<THeapObject *>(v)) {
+            dict = dynamic_cast<TDictionary *>(std::get<THeapObject *>(v));
            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)) {
-                auto dict2 = dynamic_cast<TDictionary *>(
-                    std::get<THeapObjectHolder>(v).obj);
+            if (std::holds_alternative<THeapObject *>(v)) {
+                auto dict2 =
+                    dynamic_cast<TDictionary *>(std::get<THeapObject *>(v));
                if (dict2 == nullptr) {
                    dict2 = TDictionary::Create(ls);
                    gc->BarrierBegin();
--- a/src/vm/bc/add.cpp
+++ b/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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        auto obj = std::get<THeapObject *>(left);
        auto dict = dynamic_cast<TDictionary *>(obj);
        auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
        auto natObj = dynamic_cast<TNativeObject *>(obj);
--- a/src/vm/bc/equals.cpp
+++ b/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) &&
-        std::holds_alternative<std::nullptr_t>(right)) {
+    if (IsNull(left) && IsNull(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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-                return cls == std::get<THeapObjectHolder>(right).obj;
+            } else if (std::holds_alternative<THeapObject *>(right)) {
+                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 *>(
-                        std::get<THeapObjectHolder>(fn).obj);
+                    auto 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) &&
-                std::holds_alternative<Undefined>(res)) {
+            if (!IsNull(res) && std::holds_alternative<Undefined>(res)) {
                return ToBool(res);
            }
-        } else if (native != nullptr &&
-                   std::holds_alternative<std::nullptr_t>(right)) {
+        } else if (native != nullptr && IsNull(right)) {
            return native->GetDestroyed();
        }

-        if (std::holds_alternative<THeapObjectHolder>(right)) {
-            return obj == std::get<THeapObjectHolder>(right).obj;
+        if (std::holds_alternative<THeapObject *>(right)) {
+            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;
--- a/src/vm/bc/executemethod2.cpp
+++ b/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)) {
-            auto obj = std::get<THeapObjectHolder>(instance).obj;
+        } else if (std::holds_alternative<THeapObject *>(instance)) {
+            auto obj = std::get<THeapObject *>(instance);
            auto list = dynamic_cast<TList *>(obj);
            auto dynList = dynamic_cast<TDynamicList *>(obj);
            auto bArray = dynamic_cast<TByteArray *>(obj);
--- a/src/vm/bc/getfield.cpp
+++ b/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)) {
-            auto obj = std::get<THeapObjectHolder>(instance).obj;
+        if (std::holds_alternative<THeapObject *>(instance)) {
+            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) &&
-                    dynamic_cast<TCallable *>(
-                        std::get<THeapObjectHolder>(fn).obj) != nullptr) {
+                if (std::holds_alternative<THeapObject *>(fn) &&
+                    dynamic_cast<TCallable *>(std::get<THeapObject *>(fn)) !=
+                        nullptr) {
                    return InvokeOne(ls, fn, dict);
                } else {
                    gc->BarrierBegin();
--- a/src/vm/bc/invokemethod.cpp
+++ b/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 =
-            dynamic_cast<TCallable *>(std::get<THeapObjectHolder>(fn).obj);
+        auto obj = dynamic_cast<TCallable *>(std::get<THeapObject *>(fn));
        if (obj != nullptr) {
            auto closure = dynamic_cast<TClosure *>(obj);
            if (closure != nullptr) {
--- a/src/vm/bc/invoketwo.cpp
+++ b/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 =
-            dynamic_cast<TCallable *>(std::get<THeapObjectHolder>(fn).obj);
+        auto obj = dynamic_cast<TCallable *>(std::get<THeapObject *>(fn));
        if (obj != nullptr) {
            auto closure = dynamic_cast<TClosure *>(obj);
            if (closure != nullptr) {
--- a/src/vm/bc/setfield.cpp
+++ b/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)) {
-            auto obj = std::get<THeapObjectHolder>(instance).obj;
+        if (std::holds_alternative<THeapObject *>(instance)) {
+            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) &&
-                    dynamic_cast<TCallable *>(
-                        std::get<THeapObjectHolder>(fn).obj) != nullptr) {
+                if (std::holds_alternative<THeapObject *>(fn) &&
+                    dynamic_cast<TCallable *>(std::get<THeapObject *>(fn)) !=
+                        nullptr) {
                    return InvokeTwo(ls, fn, dict, value);
                } else {
                    gc->BarrierBegin();
--- a/src/vm/bc/sub.cpp
+++ b/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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        auto obj = std::get<THeapObject *>(left);
        auto dict = dynamic_cast<TDictionary *>(obj);
        auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);

--- a/src/vm/bc/tobool.cpp
+++ b/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)) {
-        auto o = std::get<THeapObjectHolder>(obj).obj;
+    } else if (std::holds_alternative<THeapObject *>(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);
--- a/src/vm/bc/tostring.cpp
+++ b/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)) {
-        auto obj = std::get<THeapObjectHolder>(o).obj;
+    if (std::holds_alternative<THeapObject *>(o)) {
+        auto obj = std::get<THeapObject *>(o);
        auto dict = dynamic_cast<TDictionary *>(obj);
        auto list = dynamic_cast<TList *>(obj);
        auto bArray = dynamic_cast<TByteArray *>(obj);
--- a/src/vm/gc.cpp
+++ b/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)) {
-        auto _item = std::get<THeapObjectHolder>(obj).obj;
+    if (std::holds_alternative<THeapObject *>(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)) {
-        auto _item = std::get<THeapObjectHolder>(obj).obj;
+    if (std::holds_alternative<THeapObject *>(obj)) {
+        auto _item = std::get<THeapObject *>(obj);
        _item->Mark();
    }
 }
 void GC::Unwatch(TObject obj) {
-    if (std::holds_alternative<THeapObjectHolder>(obj)) {
-        auto _item = std::get<THeapObjectHolder>(obj).obj;
+    if (std::holds_alternative<THeapObject *>(obj)) {
+        auto _item = std::get<THeapObject *>(obj);
        this->BarrierBegin();
        this->objects.erase(_item);
        this->BarrierEnd();
--- a/src/vm/gclist.cpp
+++ b/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)) {
-        auto _item = std::get<THeapObjectHolder>(obj).obj;
+    if (std::holds_alternative<THeapObject *>(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)) {
-        auto _item = std::get<THeapObjectHolder>(obj).obj;
+    if (std::holds_alternative<THeapObject *>(obj)) {
+        auto _item = std::get<THeapObject *>(obj);
        this->gc->BarrierBegin();

        for (auto item : this->items) {
--- a/src/vm/vm.cpp
+++ b/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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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) &&
-        std::holds_alternative<std::nullptr_t>(right)) {
+    if (IsNull(left) && IsNull(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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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) &&
-                std::holds_alternative<Undefined>(res)) {
+            if (!IsNull(res) && std::holds_alternative<Undefined>(res)) {
                cse.back()->Push(gc, res);
                return false;
            }
        }

-        else if (native != nullptr &&
-                 std::holds_alternative<std::nullptr_t>(right)) {
+        else if (native != nullptr && IsNull(right)) {
            cse.back()->Push(gc, native->GetDestroyed());
            return false;
        }

-        if (std::holds_alternative<THeapObjectHolder>(right)) {
-            cse.back()->Push(gc, obj == std::get<THeapObjectHolder>(right).obj);
+        if (std::holds_alternative<THeapObject *>(right)) {
+            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) &&
-        std::holds_alternative<std::nullptr_t>(right)) {
+    if (IsNull(left) && IsNull(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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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) &&
-                std::holds_alternative<Undefined>(res)) {
+            if (!IsNull(res) && std::holds_alternative<Undefined>(res)) {
                cse.back()->Push(gc, res);
                return false;
            }
        }

-        else if (native != nullptr &&
-                 std::holds_alternative<std::nullptr_t>(right)) {
+        else if (native != nullptr && IsNull(right)) {
            cse.back()->Push(gc, !native->GetDestroyed());
            return false;
        }
-        if (std::holds_alternative<THeapObjectHolder>(right)) {
-            cse.back()->Push(gc, obj != std::get<THeapObjectHolder>(right).obj);
+        if (std::holds_alternative<THeapObject *>(right)) {
+            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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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)) {
-        auto obj = std::get<THeapObjectHolder>(left).obj;
+    } else if (std::holds_alternative<THeapObject *>(left)) {
+        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 =
-            dynamic_cast<TCallable *>(std::get<THeapObjectHolder>(fn).obj);
+        auto obj = dynamic_cast<TCallable *>(std::get<THeapObject *>(fn));
        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 *>(
-                    std::get<THeapObjectHolder>(fn).obj);
+                auto 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) &&
-            !std::holds_alternative<std::nullptr_t>(_res2)) {
+        if (!std::holds_alternative<Undefined>(_res2) && !IsNull(_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)) {
-        auto list =
-            dynamic_cast<TList *>(std::get<THeapObjectHolder>(objhold).obj);
+    if (std::holds_alternative<THeapObject *>(objhold)) {
+        auto list = dynamic_cast<TList *>(std::get<THeapObject *>(objhold));
        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 *>(
-            std::get<THeapObjectHolder>(objhold).obj);
-        auto cls = dynamic_cast<TClassObject *>(
-            std::get<THeapObjectHolder>(objhold).obj);
+        auto dict =
+            dynamic_cast<TDictionary *>(std::get<THeapObject *>(objhold));
+        auto cls =
+            dynamic_cast<TClassObject *>(std::get<THeapObject *>(objhold));

        if (dict != nullptr) {
            dict->SetValue(std::get<std::string>(k), value);