HIR - Clean up ExprPtr a little and add erased type types

2 files changed, 64 insertions, 37 deletions

diff --git a/src/hir/expr_ptr.cpp b/src/hir/expr_ptr.cpp
index 8231239c..1f4cb1c3 100644
--- a/src/hir/expr_ptr.cpp
+++ b/src/hir/expr_ptr.cpp
@@ -1,28 +1,34 @@
 /*
+ * MRustC - Rust Compiler
+ * - By John Hodge (Mutabah/thePowersGang)
+ *
+ * hir/expr_ptr.cpp
+ * - HIR Expression
  */
 #include <hir/expr_ptr.hpp>
 #include <hir/expr.hpp>
 
-::HIR::ExprPtr::ExprPtr():
-    node(nullptr)
+::HIR::ExprPtr::ExprPtr(::std::unique_ptr< ::HIR::ExprNode> v):
+    node( mv$(v) )
 {
 }
-::HIR::ExprPtr::ExprPtr(::std::unique_ptr< ::HIR::ExprNode> v):
-    node( v.release() )
+::std::unique_ptr< ::HIR::ExprNode> HIR::ExprPtr::into_unique()
 {
+    return node.into_unique();
 }
-::HIR::ExprPtr::~ExprPtr()
+
+
+::HIR::ExprPtrInner::ExprPtrInner(::std::unique_ptr< ::HIR::ExprNode> v):
+    ptr( v.release() )
 {
-    delete node;
 }
-::std::unique_ptr< ::HIR::ExprNode> HIR::ExprPtr::into_unique()
+::HIR::ExprPtrInner::~ExprPtrInner()
 {
-    ::std::unique_ptr< ::HIR::ExprNode> rv( this->node );
-    this->node = nullptr;
-    return rv;
+    delete ptr;
 }
-void ::HIR::ExprPtr::reset(::HIR::ExprNode* p)
+::std::unique_ptr< ::HIR::ExprNode> HIR::ExprPtrInner::into_unique()
 {
-    delete node;
-    node = p;
+    ::std::unique_ptr< ::HIR::ExprNode> rv( this->ptr );
+    this->ptr = nullptr;
+    return rv;
 }
diff --git a/src/hir/expr_ptr.hpp b/src/hir/expr_ptr.hpp
index 4060c551..21bc9e9d 100644
--- a/src/hir/expr_ptr.hpp
+++ b/src/hir/expr_ptr.hpp
@@ -16,44 +16,65 @@ namespace HIR {
 class TypeRef;
 class ExprNode;
 
+class ExprPtrInner
+{
+    ::HIR::ExprNode* ptr;
+public:
+    ExprPtrInner():
+        ptr(nullptr)
+    {}
+    ExprPtrInner(::std::unique_ptr< ::HIR::ExprNode> _);
+    ExprPtrInner(ExprPtrInner&& x):
+        ptr(x.ptr)
+    {
+        x.ptr = nullptr;
+    }
+    ~ExprPtrInner();
+    
+    ExprPtrInner& operator=(ExprPtrInner&& x)
+    {
+        this->~ExprPtrInner();
+        ptr = x.ptr;
+        x.ptr = nullptr;
+        return *this;
+    }
+    
+    ::std::unique_ptr< ::HIR::ExprNode> into_unique();
+    operator bool () const { return ptr != nullptr; }
+    ::HIR::ExprNode* get() const { return ptr; }
+    void reset(::HIR::ExprNode* p) {
+        this->~ExprPtrInner();
+        this->ptr = p;
+    }
+    
+          ::HIR::ExprNode& operator*()       { return *ptr; }
+    const ::HIR::ExprNode& operator*() const { return *ptr; }
+          ::HIR::ExprNode* operator->()       { return ptr; }
+    const ::HIR::ExprNode* operator->() const { return ptr; }
+};
+
 class ExprPtr
 {
-    ::HIR::ExprNode* node;
+    ::HIR::ExprPtrInner node;
     
 public:
     ::std::vector< ::HIR::TypeRef>  m_bindings;
+    ::std::vector< ::HIR::TypeRef>  m_erased_types;
     ::MIR::FunctionPointer  m_mir;
     
 public:
-    ExprPtr();
+    ExprPtr() {}
     ExprPtr(::std::unique_ptr< ::HIR::ExprNode> _);
-    ExprPtr(ExprPtr&& x):
-        node(x.node),
-        m_bindings( ::std::move(x.m_bindings) ),
-        m_mir( ::std::move(x.m_mir) )
-    {
-        x.node = nullptr;
-    }
-    ExprPtr& operator=(ExprPtr&& x)
-    {
-        this->~ExprPtr();
-        node = x.node;
-        m_bindings = ::std::move(x.m_bindings);
-        m_mir = ::std::move(x.m_mir);
-        x.node = nullptr;
-        return *this;
-    }
-    ~ExprPtr();
     
     ::std::unique_ptr< ::HIR::ExprNode> into_unique();
-    operator bool () const { return node != nullptr; }
-    ::HIR::ExprNode* get() const { return node; }
-    void reset(::HIR::ExprNode* p);
+    operator bool () const { return node; }
+    ::HIR::ExprNode* get() const { return node.get(); }
+    void reset(::HIR::ExprNode* p) { node.reset(p); }
     
           ::HIR::ExprNode& operator*()       { return *node; }
     const ::HIR::ExprNode& operator*() const { return *node; }
-          ::HIR::ExprNode* operator->()       { return node; }
-    const ::HIR::ExprNode* operator->() const { return node; }
+          ::HIR::ExprNode* operator->()       { return &*node; }
+    const ::HIR::ExprNode* operator->() const { return &*node; }
 };
 
 }   // namespace HIR