From 175afbafebd005e0504c407f34b07338ab4c7b17 Mon Sep 17 00:00:00 2001
From: Mike Nolan <tesses@tesses.net>
Date: Thu, 10 Sep 2026 07:21:04 -0500
Subject: [PATCH] Remove THeapObjectHolder, std::nullptr_t from variant

---
 include/CrossLang.hpp         |  31 +++++---
 src/compiler/ast.cpp          |   2 +-
 src/compiler/parser.cpp       |  12 ++-
 src/runtime_methods/json.cpp  |  16 ++--
 src/runtime_methods/std.cpp   |  29 +++----
 src/types/native.cpp          |   4 +-
 src/types/rootenvironment.cpp |  11 ++-
 src/vm/bc/add.cpp             |   4 +-
 src/vm/bc/equals.cpp          |  39 +++++-----
 src/vm/bc/executemethod2.cpp  |   6 +-
 src/vm/bc/getfield.cpp        |  10 +--
 src/vm/bc/invokemethod.cpp    |   5 +-
 src/vm/bc/invoketwo.cpp       |   5 +-
 src/vm/bc/setfield.cpp        |  10 +--
 src/vm/bc/sub.cpp             |   4 +-
 src/vm/bc/tobool.cpp          |   4 +-
 src/vm/bc/tostring.cpp        |   6 +-
 src/vm/gc.cpp                 |  12 +--
 src/vm/gclist.cpp             |   8 +-
 src/vm/vm.cpp                 | 137 ++++++++++++++++------------------
 20 files changed, 169 insertions(+), 186 deletions(-)

diff --git a/include/CrossLang.hpp b/include/CrossLang.hpp
index bb3dde1..60d3f86 100644
--- 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;
diff --git a/src/compiler/ast.cpp b/src/compiler/ast.cpp
index 945361f..235234c 100644
--- 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));
diff --git a/src/compiler/parser.cpp b/src/compiler/parser.cpp
index 3c8f770..7a21e13 100644
--- 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});
diff --git a/src/runtime_methods/json.cpp b/src/runtime_methods/json.cpp
index 9aa7bf0..709e65a 100644
--- 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);
 
diff --git a/src/runtime_methods/std.cpp b/src/runtime_methods/std.cpp
index a3a4f28..f6afc69 100644
--- 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);
                 }
diff --git a/src/types/native.cpp b/src/types/native.cpp
index 17f9c37..afa14a9 100644
--- 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;
 }
diff --git a/src/types/rootenvironment.cpp b/src/types/rootenvironment.cpp
index 7b74b5e..458a26e 100644
--- 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();
diff --git a/src/vm/bc/add.cpp b/src/vm/bc/add.cpp
index c7c4c49..39807c7 100644
--- 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);
diff --git a/src/vm/bc/equals.cpp b/src/vm/bc/equals.cpp
index 92de359..98c86fd 100644
--- 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;
diff --git a/src/vm/bc/executemethod2.cpp b/src/vm/bc/executemethod2.cpp
index 90798f5..36b604f 100644
--- 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);
diff --git a/src/vm/bc/getfield.cpp b/src/vm/bc/getfield.cpp
index a2bcd4f..e967a24 100644
--- 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();
diff --git a/src/vm/bc/invokemethod.cpp b/src/vm/bc/invokemethod.cpp
index 26c9777..e5287b4 100644
--- 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) {
diff --git a/src/vm/bc/invoketwo.cpp b/src/vm/bc/invoketwo.cpp
index 54b5c32..1a4d55d 100644
--- 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) {
diff --git a/src/vm/bc/setfield.cpp b/src/vm/bc/setfield.cpp
index b4e5cf1..0d1295e 100644
--- 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();
diff --git a/src/vm/bc/sub.cpp b/src/vm/bc/sub.cpp
index 2874072..e1db190 100644
--- 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);
 
diff --git a/src/vm/bc/tobool.cpp b/src/vm/bc/tobool.cpp
index f3ef224..b128542 100644
--- 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);
diff --git a/src/vm/bc/tostring.cpp b/src/vm/bc/tostring.cpp
index d8003de..13c0479 100644
--- 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);
diff --git a/src/vm/gc.cpp b/src/vm/gc.cpp
index b3cb524..644e7af 100644
--- 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();
diff --git a/src/vm/gclist.cpp b/src/vm/gclist.cpp
index a05adfe..4eb1c64 100644
--- 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) {
diff --git a/src/vm/vm.cpp b/src/vm/vm.cpp
index d8a251d..9adf8bf 100644
--- 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);