MIR - Wrap HIR::Path-s in MIR::Constant in unique_ptr

16 files changed, 135 insertions, 94 deletions

diff --git a/src/hir/deserialise.cpp b/src/hir/deserialise.cpp
index cd25a3cb..c5350b55 100644
--- a/src/hir/deserialise.cpp
+++ b/src/hir/deserialise.cpp
@@ -532,8 +532,8 @@
                 return ::MIR::Constant::make_Bytes( mv$(bytes) );
                 }
             _(StaticString, m_in.read_string() )
-            _(Const,  { deserialise_path() } )
-            _(ItemAddr, deserialise_path() )
+            _(Const,  { box$(deserialise_path()) } )
+            _(ItemAddr, box$(deserialise_path()) )
             #undef _
             default:
                 BUG(Span(), "Bad tag for MIR::Const - " << tag);
diff --git a/src/hir/expr_ptr.cpp b/src/hir/expr_ptr.cpp
index 0c219e0f..7f493a0d 100644
--- a/src/hir/expr_ptr.cpp
+++ b/src/hir/expr_ptr.cpp
@@ -91,11 +91,14 @@ void HIR::ExprPtr::set_mir(::MIR::FunctionPointer mir)
     assert( !this->m_mir );
     m_mir = ::std::move(mir);
     // Reset the HIR tree to be a placeholder node (thus freeing the backing memory)
-    //if( node )
-    //{
-    //    auto sp = node->span();
-    //    node = ExprPtrInner(::std::unique_ptr<HIR::ExprNode>(new ::HIR::ExprNode_Tuple(sp, {})));
-    //}
+    if( false && node )
+    {
+        auto sp = node->span();
+        node = ExprPtrInner(::std::unique_ptr<HIR::ExprNode>(new ::HIR::ExprNode_Loop(
+                        sp, "",
+                        ::std::unique_ptr<HIR::ExprNode>(new ::HIR::ExprNode_Tuple(sp, {}))
+                        )));
+    }
 }
 
 
diff --git a/src/hir/serialise.cpp b/src/hir/serialise.cpp
index e90cf995..2c72c801 100644
--- a/src/hir/serialise.cpp
+++ b/src/hir/serialise.cpp
@@ -795,10 +795,10 @@
                 m_out.write_string(e);
                 ),
             (Const,
-                serialise_path(e.p);
+                serialise_path(*e.p);
                 ),
             (ItemAddr,
-                serialise_path(e);
+                serialise_path(*e);
                 )
             )
         }
diff --git a/src/hir_conv/bind.cpp b/src/hir_conv/bind.cpp
index 940b2cab..84854315 100644
--- a/src/hir_conv/bind.cpp
+++ b/src/hir_conv/bind.cpp
@@ -729,25 +729,29 @@ namespace {
                             )
                         )
                     }
+                    static void visit_constant(Visitor& upper_visitor, ::MIR::Constant& e)
+                    {
+                        TU_MATCHA( (e), (ce),
+                        (Int, ),
+                        (Uint,),
+                        (Float, ),
+                        (Bool, ),
+                        (Bytes, ),
+                        (StaticString, ),  // String
+                        (Const,
+                            upper_visitor.visit_path(*ce.p, ::HIR::Visitor::PathContext::VALUE);
+                            ),
+                        (ItemAddr,
+                            upper_visitor.visit_path(*ce, ::HIR::Visitor::PathContext::VALUE);
+                            )
+                        )
+                    }
                     static void visit_param(Visitor& upper_visitor, ::MIR::Param& p)
                     {
                         TU_MATCHA( (p), (e),
                         (LValue, H::visit_lvalue(upper_visitor, e);),
                         (Constant,
-                            TU_MATCHA( (e), (ce),
-                            (Int, ),
-                            (Uint,),
-                            (Float, ),
-                            (Bool, ),
-                            (Bytes, ),
-                            (StaticString, ),  // String
-                            (Const,
-                                upper_visitor.visit_path(ce.p, ::HIR::Visitor::PathContext::VALUE);
-                                ),
-                            (ItemAddr,
-                                upper_visitor.visit_path(ce, ::HIR::Visitor::PathContext::VALUE);
-                                )
-                            )
+                            H::visit_constant(upper_visitor, e);
                             )
                         )
                     }
@@ -765,20 +769,7 @@ namespace {
                                 H::visit_lvalue(*this, e);
                                 ),
                             (Constant,
-                                TU_MATCHA( (e), (ce),
-                                (Int, ),
-                                (Uint,),
-                                (Float, ),
-                                (Bool, ),
-                                (Bytes, ),
-                                (StaticString, ),  // String
-                                (Const,
-                                    this->visit_path(ce.p, ::HIR::Visitor::PathContext::VALUE);
-                                    ),
-                                (ItemAddr,
-                                    this->visit_path(ce, ::HIR::Visitor::PathContext::VALUE);
-                                    )
-                                )
+                                H::visit_constant(*this, e);
                                 ),
                             (SizedArray,
                                 H::visit_param(*this, e.val);
diff --git a/src/hir_conv/constant_evaluation.cpp b/src/hir_conv/constant_evaluation.cpp
index 6067b32f..0ccb6e6f 100644
--- a/src/hir_conv/constant_evaluation.cpp
+++ b/src/hir_conv/constant_evaluation.cpp
@@ -390,11 +390,11 @@ namespace HIR {
             TU_ARM(c, StaticString, e2)
                 return ::HIR::Literal(e2);
             TU_ARM(c, Const, e2) {
-                auto p = ms.monomorph(state.sp, e2.p);
+                auto p = ms.monomorph(state.sp, *e2.p);
                 // If there's any mention of generics in this path, then return Literal::Defer
                 if( visit_path_tys_with(p, [&](const auto& ty)->bool { return ty.m_data.is_Generic(); }) )
                 {
-                    DEBUG("Return Literal::Defer for constant " << e2.p << " which references a generic parameter");
+                    DEBUG("Return Literal::Defer for constant " << *e2.p << " which references a generic parameter");
                     return ::HIR::Literal::make_Defer({});
                 }
                 MonomorphState  const_ms;
@@ -417,7 +417,7 @@ namespace HIR {
                 return clone_literal( c.m_value_res );
                 }
             TU_ARM(c, ItemAddr, e2)
-                return ::HIR::Literal::make_BorrowPath( ms.monomorph(state.sp, e2) );
+                return ::HIR::Literal::make_BorrowPath( ms.monomorph(state.sp, *e2) );
             }
             throw "";
             };
diff --git a/src/mir/cleanup.cpp b/src/mir/cleanup.cpp
index fdc0f3d4..dd5332b6 100644
--- a/src/mir/cleanup.cpp
+++ b/src/mir/cleanup.cpp
@@ -216,7 +216,7 @@ const ::HIR::Literal* MIR_Cleanup_GetConstant(const MIR::TypeResolve& state, con
         if( path == ::HIR::GenericPath() )
             MIR_TODO(state, "Literal of type " << ty << " - " << lit);
         DEBUG("Unknown type " << ty << ", but a path was provided - Return ItemAddr " << path);
-        return ::MIR::Constant( mv$(path) );
+        return ::MIR::Constant::make_ItemAddr( box$(path) );
         ),
     (Tuple,
         MIR_ASSERT(state, lit.is_List(), "Non-list literal for Tuple - " << lit);
@@ -378,7 +378,7 @@ const ::HIR::Literal* MIR_Cleanup_GetConstant(const MIR::TypeResolve& state, con
         if( const auto* pp = lit.opt_BorrowPath() )
         {
             const auto& path = *pp;
-            auto ptr_val = ::MIR::Constant::make_ItemAddr(path.clone());
+            auto ptr_val = ::MIR::Constant::make_ItemAddr(box$(path.clone()));
             // TODO: Get the metadata type (for !Sized wrapper types)
             if( te.inner->m_data.is_Slice() )
             {
@@ -397,7 +397,7 @@ const ::HIR::Literal* MIR_Cleanup_GetConstant(const MIR::TypeResolve& state, con
 
                 auto vtable_path = ::HIR::Path(&ty == &tmp ? mv$(tmp) : ty.clone(), tep->m_trait.m_path.clone(), "vtable#");
 
-                auto vtable_val = ::MIR::Param( ::MIR::Constant::make_ItemAddr(mv$(vtable_path)) );
+                auto vtable_val = ::MIR::Param( ::MIR::Constant::make_ItemAddr(box$(vtable_path)) );
 
                 return ::MIR::RValue::make_MakeDst({ ::MIR::Param(mv$(ptr_val)), mv$(vtable_val) });
             }
@@ -458,7 +458,7 @@ const ::HIR::Literal* MIR_Cleanup_GetConstant(const MIR::TypeResolve& state, con
     (Function,
         //MIR_TODO(state, "Const function pointer " << lit << " w/ type " << ty);
         MIR_ASSERT(state, lit.is_BorrowPath(), "");
-        return ::MIR::Constant::make_ItemAddr( lit.as_BorrowPath().clone() );
+        return ::MIR::Constant::make_ItemAddr( box$( lit.as_BorrowPath().clone() ) );
         )
     )
 }
@@ -703,7 +703,7 @@ bool MIR_Cleanup_Unsize_GetMetadata(const ::MIR::TypeResolve& state, MirMutator&
                 MIR_ASSERT(state, state.m_resolve.type_is_sized(state.sp, src_ty), "Attempting to get vtable for unsized type - " << src_ty);
 
                 ::HIR::Path vtable { src_ty.clone(), trait_path.m_path.clone(), "vtable#" };
-                out_meta_val = ::MIR::Constant::make_ItemAddr(mv$(vtable));
+                out_meta_val = ::MIR::Constant::make_ItemAddr(box$(vtable));
             }
         }
         return true;
@@ -1092,18 +1092,18 @@ void MIR_Cleanup(const StaticTraitResolve& resolve, const ::HIR::ItemPath& path,
                     TU_IFLET( ::MIR::Constant, e, Const, ce,
                         // 1. Find the constant
                         ::HIR::TypeRef  ty;
-                        const auto* lit_ptr = MIR_Cleanup_GetConstant(state, ce.p, ty);
+                        const auto* lit_ptr = MIR_Cleanup_GetConstant(state, *ce.p, ty);
                         if( lit_ptr && !lit_ptr->is_Defer() )
                         {
-                            DEBUG("Replace constant " << ce.p << " with " << *lit_ptr);
-                            se.src = MIR_Cleanup_LiteralToRValue(state, mutator, *lit_ptr, mv$(ty), mv$(ce.p));
+                            DEBUG("Replace constant " << *ce.p << " with " << *lit_ptr);
+                            se.src = MIR_Cleanup_LiteralToRValue(state, mutator, *lit_ptr, mv$(ty), mv$(*ce.p));
                             if( auto* p = se.src.opt_Constant() ) {
                                 MIR_Cleanup_Constant(state, mutator, *p);
                             }
                         }
                         else
                         {
-                            DEBUG("No replacement for constant " << ce.p);
+                            DEBUG("No replacement for constant " << *ce.p);
                         }
                     )
                 )
diff --git a/src/mir/dump.cpp b/src/mir/dump.cpp
index ffce8abb..b02c1e5b 100644
--- a/src/mir/dump.cpp
+++ b/src/mir/dump.cpp
@@ -244,10 +244,10 @@ namespace {
                 os << "\"" << ce << "\"";
                 ),
             (Const,
-                os << ce.p;
+                os << *ce.p;
                 ),
             (ItemAddr,
-                os << "addr " << ce;
+                os << "addr " << *ce;
                 )
             )
         }
diff --git a/src/mir/from_hir.cpp b/src/mir/from_hir.cpp
index 8d51bf55..b8549f8a 100644
--- a/src/mir/from_hir.cpp
+++ b/src/mir/from_hir.cpp
@@ -162,6 +162,7 @@ namespace {
 
         void destructure_from_ex(const Span& sp, const ::HIR::Pattern& pat, ::MIR::LValue lval, int allow_refutable=0) // 1 : yes, 2 : disallow binding
         {
+            TRACE_FUNCTION_F(pat << ", allow_refutable=" << allow_refutable);
             if( allow_refutable != 3 && pat.m_binding.is_valid() ) {
                 if( allow_refutable == 2 ) {
                     BUG(sp, "Binding when not expected");
@@ -425,9 +426,10 @@ namespace {
                         // 2. Obtain pointer to element
                         ::HIR::BorrowType   bt = H::get_borrow_type(sp, e.extra_bind);
                         ::MIR::LValue ptr_val = m_builder.lvalue_or_temp(sp,
-                            ::HIR::TypeRef::new_pointer( bt, inner_type.clone() ),
+                            ::HIR::TypeRef::new_borrow( bt, inner_type.clone() ),
                             ::MIR::RValue::make_Borrow({ 0, bt, ::MIR::LValue::make_Field({ box$(lval.clone()), static_cast<unsigned int>(e.leading.size()) }) })
                             );
+                        // TODO: Cast to raw pointer? Or keep as a borrow?
 
                         // Construct fat pointer
                         m_builder.push_stmt_assign( sp, m_builder.get_variable(sp, e.extra_bind.m_slot), ::MIR::RValue::make_MakeDst({ mv$(ptr_val), mv$(len_val) }) );
@@ -2185,7 +2187,7 @@ namespace {
 
                     // TODO: Ideally, the creation of the wrapper function would happen somewhere before trans?
                     auto tmp = m_builder.new_temporary( node.m_res_type );
-                    m_builder.push_stmt_assign( sp, tmp.clone(), ::MIR::Constant::make_ItemAddr(node.m_path.clone()) );
+                    m_builder.push_stmt_assign( sp, tmp.clone(), ::MIR::Constant::make_ItemAddr(box$(node.m_path.clone())) );
                     m_builder.set_result( sp, mv$(tmp) );
                     return ;
                 }
@@ -2196,7 +2198,7 @@ namespace {
                     ),
                 (Constant,
                     auto tmp = m_builder.new_temporary( e.m_type );
-                    m_builder.push_stmt_assign( sp, tmp.clone(), ::MIR::Constant::make_Const({node.m_path.clone()}) );
+                    m_builder.push_stmt_assign( sp, tmp.clone(), ::MIR::Constant::make_Const({box$(node.m_path.clone())}) );
                     m_builder.set_result( node.span(), mv$(tmp) );
                     ),
                 (Static,
@@ -2245,13 +2247,13 @@ namespace {
                         fcn_ty_data.m_arg_types.push_back( monomorphise_type_with(sp, arg.second, monomorph_cb) );
                     }
                     auto tmp = m_builder.new_temporary( ::HIR::TypeRef( mv$(fcn_ty_data) ) );
-                    m_builder.push_stmt_assign( sp, tmp.clone(), ::MIR::Constant::make_ItemAddr(node.m_path.clone()) );
+                    m_builder.push_stmt_assign( sp, tmp.clone(), ::MIR::Constant::make_ItemAddr(box$(node.m_path.clone())) );
                     m_builder.set_result( sp, mv$(tmp) );
                     ),
                 (StructConstructor,
                     // TODO: Ideally, the creation of the wrapper function would happen somewhere before this?
                     auto tmp = m_builder.new_temporary( node.m_res_type );
-                    m_builder.push_stmt_assign( sp, tmp.clone(), ::MIR::Constant::make_ItemAddr(node.m_path.clone()) );
+                    m_builder.push_stmt_assign( sp, tmp.clone(), ::MIR::Constant::make_ItemAddr(box$(node.m_path.clone())) );
                     m_builder.set_result( sp, mv$(tmp) );
                     )
                 )
@@ -2263,13 +2265,13 @@ namespace {
                 ASSERT_BUG(sp, it != tr.m_values.end(), "Cannot find trait item for " << node.m_path);
                 TU_MATCHA( (it->second), (e),
                 (Constant,
-                    m_builder.set_result( sp, ::MIR::Constant::make_Const({node.m_path.clone()}) );
+                    m_builder.set_result( sp, ::MIR::Constant::make_Const({box$(node.m_path.clone())}) );
                     ),
                 (Static,
                     TODO(sp, "Associated statics (non-rustc) - " << node.m_path);
                     ),
                 (Function,
-                    m_builder.set_result( sp, ::MIR::Constant::make_ItemAddr(node.m_path.clone()) );
+                    m_builder.set_result( sp, ::MIR::Constant::make_ItemAddr(box$(node.m_path.clone())) );
                     )
                 )
                 ),
@@ -2285,7 +2287,7 @@ namespace {
                         {
                             auto it = impl.m_methods.find(pe.item);
                             if( it != impl.m_methods.end() ) {
-                                m_builder.set_result( sp, ::MIR::Constant::make_ItemAddr(node.m_path.clone()) );
+                                m_builder.set_result( sp, ::MIR::Constant::make_ItemAddr(box$(node.m_path.clone())) );
                                 return true;
                             }
                         }
@@ -2293,7 +2295,7 @@ namespace {
                         {
                             auto it = impl.m_constants.find(pe.item);
                             if( it != impl.m_constants.end() ) {
-                                m_builder.set_result( sp, ::MIR::Constant::make_Const({node.m_path.clone()}) );
+                                m_builder.set_result( sp, ::MIR::Constant::make_Const({box$(node.m_path.clone())}) );
                                 return true;
                             }
                         }
diff --git a/src/mir/helpers.cpp b/src/mir/helpers.cpp
index 38388aed..1453acb3 100644
--- a/src/mir/helpers.cpp
+++ b/src/mir/helpers.cpp
@@ -270,7 +270,7 @@ const ::HIR::TypeRef& MIR::TypeResolve::get_param_type(::HIR::TypeRef& tmp, cons
         ),
     (Const,
         MonomorphState  p;
-        auto v = m_resolve.get_value(this->sp, e.p, p, /*signature_only=*/true);
+        auto v = m_resolve.get_value(this->sp, *e.p, p, /*signature_only=*/true);
         if( const auto* ve = v.opt_Constant() ) {
             const auto& ty = (*ve)->m_type;
             if( monomorphise_type_needed(ty) ) {
@@ -282,12 +282,12 @@ const ::HIR::TypeRef& MIR::TypeResolve::get_param_type(::HIR::TypeRef& tmp, cons
                 return ty.clone();
         }
         else {
-            MIR_BUG(*this, "get_const_type - Not a constant " << e.p);
+            MIR_BUG(*this, "get_const_type - Not a constant " << *e.p);
         }
         ),
     (ItemAddr,
         MonomorphState  p;
-        auto v = m_resolve.get_value(this->sp, e, p, /*signature_only=*/true);
+        auto v = m_resolve.get_value(this->sp, *e, p, /*signature_only=*/true);
         TU_MATCHA( (v), (ve),
         (NotFound,
             MIR_BUG(*this, "get_const_type - ItemAddr points to unknown value - " << c);
@@ -325,7 +325,7 @@ const ::HIR::TypeRef& MIR::TypeResolve::get_param_type(::HIR::TypeRef& tmp, cons
             ::HIR::FunctionType ft;
             ft.is_unsafe = false;
             ft.m_abi = ABI_RUST;
-            auto enum_path = e.clone();
+            auto enum_path = e->clone();
             enum_path.m_data.as_Generic().m_path.m_components.pop_back();
             ft.m_rettype = box$( ::HIR::TypeRef::new_path(mv$(enum_path), ve.e) );
             ft.m_arg_types.reserve(str_data.size());
@@ -348,7 +348,7 @@ const ::HIR::TypeRef& MIR::TypeResolve::get_param_type(::HIR::TypeRef& tmp, cons
             ::HIR::FunctionType ft;
             ft.is_unsafe = false;
             ft.m_abi = ABI_RUST;
-            ft.m_rettype = box$( ::HIR::TypeRef::new_path( ::HIR::GenericPath(*ve.p, e.m_data.as_Generic().m_params.clone()), &str) );
+            ft.m_rettype = box$( ::HIR::TypeRef::new_path( ::HIR::GenericPath(*ve.p, e->m_data.as_Generic().m_params.clone()), &str) );
             ft.m_arg_types.reserve(str_data.size());
             for(const auto& fld : str_data)
                 ft.m_arg_types.push_back( p.monomorph(this->sp, fld.ent) );
diff --git a/src/mir/mir.cpp b/src/mir/mir.cpp
index 657e695d..638b8e46 100644
--- a/src/mir/mir.cpp
+++ b/src/mir/mir.cpp
@@ -44,10 +44,10 @@ namespace MIR {
             os << "\"" << FmtEscaped(e) << "\"";
             ),
         (Const,
-            os << e.p;
+            os << *e.p;
             ),
         (ItemAddr,
-            os << "&" << e;
+            os << "&" << *e;
             )
         )
         return os;
@@ -82,10 +82,10 @@ namespace MIR {
             return ::ord(ae, be);
             ),
         (Const,
-            return ::ord(ae.p, be.p);
+            return ::ord(*ae.p, *be.p);
             ),
         (ItemAddr,
-            return ::ord(ae, be);
+            return ::ord(*ae, *be);
             )
         )
         throw "";
@@ -571,8 +571,8 @@ namespace MIR {
     (Bool, return ::MIR::Constant(e2); ),
     (Bytes, return ::MIR::Constant(e2); ),
     (StaticString, return ::MIR::Constant(e2); ),
-    (Const, return ::MIR::Constant::make_Const({e2.p.clone()}); ),
-    (ItemAddr, return ::MIR::Constant(e2.clone()); )
+    (Const, return ::MIR::Constant::make_Const({box$(e2.p->clone())}); ),
+    (ItemAddr, return ::MIR::Constant(box$(e2->clone())); )
     )
     throw "";
 }
diff --git a/src/mir/mir.hpp b/src/mir/mir.hpp
index 7100d4aa..c24aac51 100644
--- a/src/mir/mir.hpp
+++ b/src/mir/mir.hpp
@@ -26,7 +26,21 @@ struct LValue
     class Storage
     {
         uintptr_t   val;
+        static uintptr_t MAX_ARG = (1 << 30) - 1; // max value of 30 bits
     public:
+        Storage(const Storage&) = delete;
+        Storage& operator=(const Storage&) = delete;
+        Storage(Storage&& x)
+            :val(x.val)
+        {
+            x.val = 0;
+        }
+        Storage& operator=(Storage&& x)
+        {
+            this->~Storage();
+            this->val = x.val;
+            x.val = 0;
+        }
         ~Storage()
         {
             if( is_Static() ) {
@@ -34,32 +48,64 @@ struct LValue
                 val = 0;
             }
         }
+
+        static Storage new_Return() { return Storage { MAX_ARG << 2 }; }
+        static Storage new_Argument(unsigned idx) { assert(idx < MAX_ARG); return Storage { idx << 2 }; )
+        static Storage new_Local(unsigned idx) { assert(idx <= MAX_ARG); return Storage { (idx << 2) | 1 } };
+        static Storage new_Static(::HIR::Path p) {
+            ::HIR::Path* ptr = new ::HIR::Path(::std::move(p));
+            return Storage { static_cast<uintptr_t>(ptr) | 2; }
+        }
+
+        bool is_Return() const   { return val == (MAX_ARG << 2) /*&& (val & 3) == 0*/; }
         bool is_Argument() const { return val != (MAX_ARG << 2) && (val & 3) == 0; }
-        bool is_Return() const { return val == (MAX_ARG << 2); }
-        bool is_Local() const { return (val & 3) == 1; }
-        bool is_Static() const { return (val & 3) == 2; }
+        bool is_Local() const    { return (val & 3) == 1; }
+        bool is_Static() const   { return (val & 3) == 2; }
 
+        // No as_Return
+        unsigned as_Argument() const { assert(is_Argument()); return val >> 2; }
+        unsigned as_Local() const { assert(is_Local()); return val >> 2; }
         const ::HIR::Path& as_Static() const { assert(is_Static()); return *reinterpret_cast<const ::HIR::Path*>(val & ~3u); }
     };
     class Wrapper
     {
         uintptr_t   val;
     public:
-        bool is_Deref() const { return (val & 3) == 0; }
+        static Wrapper new_Deref() { return Wrapper { 0 }; }
+        static Wrapepr new_Field   (unsigned idx) { return Wrapper { (idx << 2) | 1 }; }
+        static Wrapepr new_Downcast(unsigned idx) { return Wrapper { (idx << 2) | 2 }; }
+        static Wrapepr new_Index   (unsigned idx) { return Wrapper { (idx << 2) | 3 }; }
+
+        bool is_Deref   () const { return (val & 3) == 0; }
         // Stores the field index
-        bool is_Field() const { return (val & 3) == 1; }
+        bool is_Field   () const { return (val & 3) == 1; }
         // Stores the variant index
         bool is_Downcast() const { return (val & 3) == 2; }
         // Stores a Local index
-        bool is_Index() const { return (val & 3) == 3; }
+        bool is_Index   () const { return (val & 3) == 3; }
 
+        // no as_Deref()
         const unsigned as_Field() const { assert(is_Field()); return (val >> 2); }
+        const unsigned as_Downcast() const { assert(is_Downcast()); return (val >> 2); }
+        // TODO: Should this return a LValue?
         const unsigned as_Index() const { assert(is_Index()); return (val >> 2); }
     };
 
     Storage m_root;
     ::std::vector<Wrapper>  m_wrappers;
 
+    static LValue new_Return() { return LValue { Storage::new_Return(), {} }; }
+    static LValue new_Argument(unsigned idx) { return LValue { Storage::new_Argument(idx), {} }; }
+    static LValue new_Local(unsigned idx) { return LValue { Storage::new_Local(idx), {} }; }
+    static LValue new_Static(::HIR::Path p) { return LValue { Storage::new_Static(::std::move(p)), {} }; }
+
+    static LValue new_Deref(LValue lv) { lv.m_wrappers.push_back(Wrapper::new_Deref()); }
+    static LValue new_Field(LValue lv, unsigned idx)    { lv.m_wrappers.push_back(Wrapper::new_Field(idx)); }
+    static LValue new_Downcast(LValue lv, unsigned idx) { lv.m_wrappers.push_back(Wrapper::new_Downcast(idx)); }
+    static LValue new_Index(LValue lv, unsigned local_idx) { lv.m_wrappers.push_back(Wrapper::new_Index(local_idx)); }
+
+    LValue monomorphise(const MonomorphState& ms, unsigned local_offset=0);
+    //LValue monomorphise(const TransParams& ms, unsigned local_offset=0);
     LValue clone() const;
 
     class Ref
@@ -159,11 +205,10 @@ TAGGED_UNION_EX(Constant, (), Int, (
         }),
     (Bytes, ::std::vector< ::std::uint8_t>),    // Byte string
     (StaticString, ::std::string),  // String
-    // TODO: Should these ::HIR::Path structures be behind pointers?
-    // - HIR::Path is ~11 words long, without it MIR::Constant is 4 instead of 12
-    // - MIR::Param is quite common, potential large space saving.
-    (Const, struct { ::HIR::Path p; }),   // `const`
-    (ItemAddr, ::HIR::Path) // address of a value
+    // NOTE: These are behind pointers to save inline space (HIR::Path is ~11
+    // words, compared to 4 for MIR::Constant without it)
+    (Const, struct { ::std::unique_ptr<::HIR::Path> p; }),   // `const`
+    (ItemAddr, ::std::unique_ptr<::HIR::Path>) // address of a value
     ), (), (), (
         friend ::std::ostream& operator<<(::std::ostream& os, const Constant& v);
         ::Ordering ord(const Constant& b) const;
diff --git a/src/mir/optimise.cpp b/src/mir/optimise.cpp
index 7c284546..a45b1c05 100644
--- a/src/mir/optimise.cpp
+++ b/src/mir/optimise.cpp
@@ -1213,10 +1213,10 @@ bool MIR_Optimise_Inlining(::MIR::TypeResolve& state, ::MIR::Function& fcn, bool
             (Bytes, return ::MIR::Constant(ce);),
             (StaticString, return ::MIR::Constant(ce);),
             (Const,
-                return ::MIR::Constant::make_Const({ this->monomorph(ce.p) });
+                return ::MIR::Constant::make_Const({ box$(this->monomorph(*ce.p)) });
                 ),
             (ItemAddr,
-                return ::MIR::Constant::make_ItemAddr(this->monomorph(ce));
+                return ::MIR::Constant::make_ItemAddr(box$(this->monomorph(*ce)));
                 )
             )
             throw "";
diff --git a/src/trans/codegen_c.cpp b/src/trans/codegen_c.cpp
index 08b4f2de..d238a523 100644
--- a/src/trans/codegen_c.cpp
+++ b/src/trans/codegen_c.cpp
@@ -5743,7 +5743,7 @@ namespace {
             (Const,
                 // TODO: This should have been eliminated? ("MIR Cleanup" should have removed all inline Const references)
                 ::HIR::TypeRef  ty;
-                const auto& lit = get_literal_for_const(c.p, ty);
+                const auto& lit = get_literal_for_const(*c.p, ty);
                 if(lit.is_Integer() || lit.is_Float())
                 {
                     emit_literal(ty, lit, {});
@@ -5764,7 +5764,7 @@ namespace {
                 }
                 ),
             (ItemAddr,
-                TU_MATCHA( (c.m_data), (pe),
+                TU_MATCHA( (c->m_data), (pe),
                 (Generic,
                     if( pe.m_path.m_components.size() > 1 && m_crate.get_typeitem_by_path(sp, pe.m_path, false, true).is_Enum() )
                         ;
@@ -5781,7 +5781,7 @@ namespace {
                     }
                     ),
                 (UfcsUnknown,
-                    MIR_BUG(*m_mir_res, "UfcsUnknown in trans " << c);
+                    MIR_BUG(*m_mir_res, "UfcsUnknown in trans " << *c);
                     ),
                 (UfcsInherent,
                     // TODO: If the target is a function, don't emit the &
@@ -5792,7 +5792,7 @@ namespace {
                     m_of << "&";
                     )
                 )
-                m_of << Trans_Mangle(c);
+                m_of << Trans_Mangle(*c);
                 )
             )
         }
diff --git a/src/trans/codegen_mmir.cpp b/src/trans/codegen_mmir.cpp
index 4867cf6f..51b8aac3 100644
--- a/src/trans/codegen_mmir.cpp
+++ b/src/trans/codegen_mmir.cpp
@@ -104,7 +104,7 @@ namespace
             os << " " << v.t;
             } break;
         TU_ARM(e, ItemAddr, v) {
-            os << "ADDROF " << v;
+            os << "ADDROF " << *v;
             } break;
         default:
             os << e;
diff --git a/src/trans/enumerate.cpp b/src/trans/enumerate.cpp
index 00b938ff..934f40a2 100644
--- a/src/trans/enumerate.cpp
+++ b/src/trans/enumerate.cpp
@@ -1541,10 +1541,10 @@ void Trans_Enumerate_FillFrom_MIR_Constant(EnumState& state, const ::MIR::Consta
     (StaticString, ),  // String
     (Const,
         // - Check if this constant has a value of Defer
-        Trans_Enumerate_FillFrom_Path(state, ce.p, pp);
+        Trans_Enumerate_FillFrom_Path(state, *ce.p, pp);
         ),
     (ItemAddr,
-        Trans_Enumerate_FillFrom_Path(state, ce, pp);
+        Trans_Enumerate_FillFrom_Path(state, *ce, pp);
         )
     )
 }
diff --git a/src/trans/monomorphise.cpp b/src/trans/monomorphise.cpp
index cf101443..50924e2f 100644
--- a/src/trans/monomorphise.cpp
+++ b/src/trans/monomorphise.cpp
@@ -71,15 +71,15 @@ namespace {
             ),
         (Const,
             return ::MIR::Constant::make_Const({
-                params.monomorph(resolve, ce.p)
+                box$(params.monomorph(resolve, *ce.p))
                 });
             ),
         (ItemAddr,
-            auto p = params.monomorph(resolve, ce);
+            auto p = params.monomorph(resolve, *ce);
             // TODO: If this is a pointer to a function on a trait object, replace with the address loaded from the vtable.
             // - Requires creating a new temporary for the vtable pointer.
             // - Also requires knowing what the receiver is.
-            return ::MIR::Constant( mv$(p) );
+            return ::MIR::Constant( box$(p) );
             )
         )
         throw "";