HIR - Move borrow ops to their own node type

10 files changed, 92 insertions, 80 deletions

diff --git a/src/hir/expr.cpp b/src/hir/expr.cpp
index a1bd5e9f..891aae0f 100644
--- a/src/hir/expr.cpp
+++ b/src/hir/expr.cpp
@@ -58,6 +58,9 @@ DEF_VISIT(ExprNode_BinOp, node,
 DEF_VISIT(ExprNode_UniOp, node,
     visit_node_ptr(node.m_value);
 )
+DEF_VISIT(ExprNode_Borrow, node,
+    visit_node_ptr(node.m_value);
+)
 DEF_VISIT(ExprNode_Cast, node,
     visit_node_ptr(node.m_value);
 )
diff --git a/src/hir/expr.hpp b/src/hir/expr.hpp
index f69429f6..8da873c1 100644
--- a/src/hir/expr.hpp
+++ b/src/hir/expr.hpp
@@ -301,15 +301,11 @@ struct ExprNode_UniOp:
     public ExprNode
 {
     enum class Op {
-        Ref,    // '& <expr>'
-        RefMut, // '&mut <expr>'
         Invert, // '!<expr>'
         Negate, // '-<expr>'
     };
     static const char* opname(Op v) {
         switch(v) {
-        case Op::Ref:   return "&";
-        case Op::RefMut:return "&mut";
         case Op::Invert:return "!";
         case Op::Negate:return "-";
         }
@@ -327,6 +323,20 @@ struct ExprNode_UniOp:
     
     NODE_METHODS();
 };
+struct ExprNode_Borrow:
+    public ExprNode
+{
+    ::HIR::BorrowType   m_type;
+    ::HIR::ExprNodeP    m_value;
+
+    ExprNode_Borrow(Span sp, ::HIR::BorrowType bt, ::HIR::ExprNodeP value):
+        ExprNode( mv$(sp) ),
+        m_type(bt),
+        m_value( mv$(value) )
+    {}
+    
+    NODE_METHODS();
+};
 struct ExprNode_Cast:
     public ExprNode
 {
@@ -731,6 +741,7 @@ public:
     NV(ExprNode_Assign)
     NV(ExprNode_BinOp)
     NV(ExprNode_UniOp)
+    NV(ExprNode_Borrow)
     NV(ExprNode_Cast)   // Conversion
     NV(ExprNode_Unsize) // Coercion
     NV(ExprNode_Index)
@@ -773,6 +784,7 @@ public:
     NV(ExprNode_Assign)
     NV(ExprNode_BinOp)
     NV(ExprNode_UniOp)
+    NV(ExprNode_Borrow)
     NV(ExprNode_Cast)
     NV(ExprNode_Unsize)
     NV(ExprNode_Index)
diff --git a/src/hir/from_ast_expr.cpp b/src/hir/from_ast_expr.cpp
index 66617075..f8d3fd69 100644
--- a/src/hir/from_ast_expr.cpp
+++ b/src/hir/from_ast_expr.cpp
@@ -194,8 +194,13 @@ struct LowerHIR_ExprNode_Visitor:
             BUG(v.get_pos(), "Encounterd question mark operator (should have been expanded in AST)");
             break;
         
-        case ::AST::ExprNode_UniOp::REF:    op = ::HIR::ExprNode_UniOp::Op::Ref   ; if(0)
-        case ::AST::ExprNode_UniOp::REFMUT: op = ::HIR::ExprNode_UniOp::Op::RefMut; if(0)
+        case ::AST::ExprNode_UniOp::REF:
+            m_rv.reset(new ::HIR::ExprNode_Borrow(v.span(), ::HIR::BorrowType::Shared, LowerHIR_ExprNode_Inner( *v.m_value ) ));
+            break;
+        case ::AST::ExprNode_UniOp::REFMUT:
+            m_rv.reset(new ::HIR::ExprNode_Borrow(v.span(), ::HIR::BorrowType::Unique, LowerHIR_ExprNode_Inner( *v.m_value ) ));
+            break;
+        
         case ::AST::ExprNode_UniOp::INVERT: op = ::HIR::ExprNode_UniOp::Op::Invert; if(0)
         case ::AST::ExprNode_UniOp::NEGATE: op = ::HIR::ExprNode_UniOp::Op::Negate;
             m_rv.reset( new ::HIR::ExprNode_UniOp( v.span(),
diff --git a/src/hir_conv/constant_evaluation.cpp b/src/hir_conv/constant_evaluation.cpp
index 43e1eff3..53997e20 100644
--- a/src/hir_conv/constant_evaluation.cpp
+++ b/src/hir_conv/constant_evaluation.cpp
@@ -322,10 +322,6 @@ namespace {
                 
                 switch(node.m_op)
                 {
-                case ::HIR::ExprNode_UniOp::Op::Ref:
-                case ::HIR::ExprNode_UniOp::Op::RefMut:
-                    TODO(node.span(), "&/&mut in constant");
-                    break;
                 case ::HIR::ExprNode_UniOp::Op::Invert:
                     TU_MATCH_DEF(::HIR::Literal, (val), (e),
                     ( throw ""; ),
@@ -342,6 +338,9 @@ namespace {
                     break;
                 }
             }
+            void visit(::HIR::ExprNode_Borrow& node) override {
+                TODO(node.span(), "&/&mut in constant");
+            }
             void visit(::HIR::ExprNode_Cast& node) override {
                 TRACE_FUNCTION_F("_Cast");
                 node.m_value->visit(*this);
diff --git a/src/hir_expand/annotate_value_usage.cpp b/src/hir_expand/annotate_value_usage.cpp
index ea560bbc..eec4fd86 100644
--- a/src/hir_expand/annotate_value_usage.cpp
+++ b/src/hir_expand/annotate_value_usage.cpp
@@ -149,18 +149,25 @@ namespace {
         }
         void visit(::HIR::ExprNode_UniOp& node) override
         {
-            switch(node.m_op)
+            m_usage.push_back( ::HIR::ValueUsage::Move );
+            
+            this->visit_node_ptr(node.m_value);
+            
+            m_usage.pop_back();
+        }
+        void visit(::HIR::ExprNode_Borrow& node) override
+        {
+            switch(node.m_type)
             {
-            case ::HIR::ExprNode_UniOp::Op::Invert:
-            case ::HIR::ExprNode_UniOp::Op::Negate:
-                m_usage.push_back( ::HIR::ValueUsage::Move );
-                break;
-            case ::HIR::ExprNode_UniOp::Op::Ref:
+            case ::HIR::BorrowType::Shared:
                 m_usage.push_back( ::HIR::ValueUsage::Borrow );
                 break;
-            case ::HIR::ExprNode_UniOp::Op::RefMut:
+            case ::HIR::BorrowType::Unique:
                 m_usage.push_back( ::HIR::ValueUsage::Mutate );
                 break;
+            case ::HIR::BorrowType::Owned:
+                m_usage.push_back( ::HIR::ValueUsage::Move );
+                break;
             }
             
             this->visit_node_ptr(node.m_value);
diff --git a/src/hir_expand/closures.cpp b/src/hir_expand/closures.cpp
index ecb59c02..0a6c2cb6 100644
--- a/src/hir_expand/closures.cpp
+++ b/src/hir_expand/closures.cpp
@@ -382,7 +382,7 @@ namespace {
                     auto dispatch_node = NEWNODE(ret_type.clone(), CallPath, sp,
                         ::HIR::Path(closure_type.clone(), ::HIR::GenericPath(lang_Fn, trait_params.clone()), "call"),
                         make_vec2(
-                            NEWNODE(method_self_ty.clone(), UniOp, sp, ::HIR::ExprNode_UniOp::Op::Ref, NEWNODE(closure_type.clone(), Variable, sp, "self", 0)),
+                            NEWNODE(method_self_ty.clone(), Borrow, sp, ::HIR::BorrowType::Shared, NEWNODE(closure_type.clone(), Variable, sp, "self", 0)),
                             NEWNODE(args_ty.clone(), Variable, sp, "arg", 1)
                             )
                         );
@@ -401,7 +401,7 @@ namespace {
                     auto dispatch_node = NEWNODE(ret_type.clone(), CallPath, sp,
                         ::HIR::Path(closure_type.clone(), ::HIR::GenericPath(lang_Fn, trait_params.clone()), "call"),
                         make_vec2(
-                            NEWNODE(method_self_ty.clone(), UniOp, sp, ::HIR::ExprNode_UniOp::Op::Ref, NEWNODE(closure_type.clone(), Deref, sp, NEWNODE(::HIR::TypeRef(), Variable, sp, "self", 0))),
+                            NEWNODE(method_self_ty.clone(), Borrow, sp, ::HIR::BorrowType::Shared, NEWNODE(closure_type.clone(), Deref, sp, NEWNODE(::HIR::TypeRef(), Variable, sp, "self", 0))),
                             NEWNODE(args_ty.clone(), Variable, sp, "arg", 1)
                             )
                         );
@@ -431,7 +431,7 @@ namespace {
                     auto dispatch_node = NEWNODE(ret_type.clone(), CallPath, sp,
                         ::HIR::Path(closure_type.clone(), ::HIR::GenericPath(lang_FnMut, trait_params.clone()), "call"),
                         make_vec2(
-                            NEWNODE(method_self_ty.clone(), UniOp, sp, ::HIR::ExprNode_UniOp::Op::RefMut, NEWNODE(closure_type.clone(), Variable, sp, "self", 0)),
+                            NEWNODE(method_self_ty.clone(), Borrow, sp, ::HIR::BorrowType::Unique, NEWNODE(closure_type.clone(), Variable, sp, "self", 0)),
                             NEWNODE(args_ty.clone(), Variable, sp, "arg", 1)
                             )
                         );
diff --git a/src/hir_expand/ufcs_everything.cpp b/src/hir_expand/ufcs_everything.cpp
index 3785d86c..84735f45 100644
--- a/src/hir_expand/ufcs_everything.cpp
+++ b/src/hir_expand/ufcs_everything.cpp
@@ -301,9 +301,7 @@ namespace {
             
             auto slot_type_refmut = ::HIR::TypeRef::new_borrow(::HIR::BorrowType::Unique, ty_slot.clone());
             ::std::vector< ::HIR::ExprNodeP>    args;
-            args.push_back( NEWNODE( slot_type_refmut.clone(), UniOp, sp,
-                ::HIR::ExprNode_UniOp::Op::RefMut, mv$(node.m_slot)
-                ) );
+            args.push_back(NEWNODE( slot_type_refmut.clone(), Borrow, sp,  ::HIR::BorrowType::Unique, mv$(node.m_slot) ));
             args.push_back( mv$(node.m_value) );
             m_replacement = NEWNODE(mv$(node.m_res_type), CallPath, sp,
                 ::HIR::Path(ty_slot.clone(), mv$(trait), opname),
@@ -363,12 +361,8 @@ namespace {
                 auto ty_r_ref = ::HIR::TypeRef::new_borrow( ::HIR::BorrowType::Shared, ty_r.clone() );
                 
                 ::std::vector< ::HIR::ExprNodeP>    args;
-                args.push_back( NEWNODE(ty_l_ref.clone(), UniOp, node.m_left->span(),
-                    ::HIR::ExprNode_UniOp::Op::Ref, mv$(node.m_left)
-                    ) );
-                args.push_back( NEWNODE(ty_r_ref.clone(), UniOp, node.m_right->span(),
-                    ::HIR::ExprNode_UniOp::Op::Ref, mv$(node.m_right)
-                    ) );
+                args.push_back(NEWNODE(ty_l_ref.clone(), Borrow, node.m_left ->span(),  ::HIR::BorrowType::Shared, mv$(node.m_left ) ));
+                args.push_back(NEWNODE(ty_r_ref.clone(), Borrow, node.m_right->span(),  ::HIR::BorrowType::Shared, mv$(node.m_right) ));
                 
                 m_replacement = NEWNODE(mv$(node.m_res_type), CallPath, sp,
                     ::HIR::Path(ty_l.clone(), mv$(trait), method),
@@ -450,10 +444,6 @@ namespace {
             const char* method = nullptr;
             switch(node.m_op)
             {
-            case ::HIR::ExprNode_UniOp::Op::Ref:
-            case ::HIR::ExprNode_UniOp::Op::RefMut:
-                // & and &mut are always valid
-                return;
             case ::HIR::ExprNode_UniOp::Op::Invert:
                 // Check if the operation is valid in the MIR.
                 if( ty_val.m_data.is_Primitive() ) {
@@ -552,7 +542,6 @@ namespace {
             const char* langitem = nullptr;
             const char* method = nullptr;
             ::HIR::BorrowType   bt;
-            ::HIR::ExprNode_UniOp::Op   op;
             switch( node.m_value->m_usage )
             {
             case ::HIR::ValueUsage::Unknown:
@@ -560,12 +549,10 @@ namespace {
                 break;
             case ::HIR::ValueUsage::Borrow:
                 bt = ::HIR::BorrowType::Shared;
-                op = ::HIR::ExprNode_UniOp::Op::Ref;
                 langitem = method = "index";
                 break;
             case ::HIR::ValueUsage::Mutate:
                 bt = ::HIR::BorrowType::Unique;
-                op = ::HIR::ExprNode_UniOp::Op::RefMut;
                 langitem = method = "index_mut";
                 break;
             case ::HIR::ValueUsage::Move:
@@ -582,7 +569,7 @@ namespace {
             ::HIR::GenericPath  trait { m_crate.get_lang_item_path(node.span(), langitem), mv$(pp) };
             
             ::std::vector< ::HIR::ExprNodeP>    args;
-            args.push_back( NEWNODE( ::HIR::TypeRef::new_borrow(bt, ty_val.clone()), UniOp, sp, op, mv$(node.m_value) ) );
+            args.push_back( NEWNODE( ::HIR::TypeRef::new_borrow(bt, ty_val.clone()), Borrow, sp, bt, mv$(node.m_value) ) );
             args.push_back( mv$(node.m_index) );
             
             m_replacement = NEWNODE( ::HIR::TypeRef::new_borrow(bt, node.m_res_type.clone()), CallPath, sp,
diff --git a/src/hir_typeck/expr_check.cpp b/src/hir_typeck/expr_check.cpp
index a249caef..b8f273b8 100644
--- a/src/hir_typeck/expr_check.cpp
+++ b/src/hir_typeck/expr_check.cpp
@@ -209,12 +209,6 @@ namespace {
             TRACE_FUNCTION_F(&node << " " << ::HIR::ExprNode_UniOp::opname(node.m_op) << "...");
             switch(node.m_op)
             {
-            case ::HIR::ExprNode_UniOp::Op::Ref:
-                check_types_equal(node.span(), node.m_res_type, ::HIR::TypeRef::new_borrow(::HIR::BorrowType::Shared, node.m_value->m_res_type.clone()));
-                break;
-            case ::HIR::ExprNode_UniOp::Op::RefMut:
-                check_types_equal(node.span(), node.m_res_type, ::HIR::TypeRef::new_borrow(::HIR::BorrowType::Unique, node.m_value->m_res_type.clone()));
-                break;
             case ::HIR::ExprNode_UniOp::Op::Invert:
                 check_associated_type(node.span(), node.m_res_type,  this->get_lang_item_path(node.span(), "not"), {}, node.m_value->m_res_type, "Output");
                 break;
@@ -224,6 +218,12 @@ namespace {
             }
             node.m_value->visit( *this );
         }
+        void visit(::HIR::ExprNode_Borrow& node) override
+        {
+            TRACE_FUNCTION_F(&node << " &_ ...");
+            check_types_equal(node.span(), node.m_res_type, ::HIR::TypeRef::new_borrow(node.m_type, node.m_value->m_res_type.clone()));
+            node.m_value->visit( *this );
+        }
         void visit(::HIR::ExprNode_Index& node) override
         {
             TRACE_FUNCTION_F(&node << " ... [ ... ]");
diff --git a/src/hir_typeck/expr_cs.cpp b/src/hir_typeck/expr_cs.cpp
index b2cc1dd2..3a0356cc 100644
--- a/src/hir_typeck/expr_cs.cpp
+++ b/src/hir_typeck/expr_cs.cpp
@@ -653,13 +653,6 @@ namespace {
             this->context.add_ivars( node.m_value->m_res_type );
             switch(node.m_op)
             {
-            case ::HIR::ExprNode_UniOp::Op::Ref:
-                // TODO: Can Ref/RefMut trigger coercions?
-                this->context.equate_types(node.span(), node.m_res_type, ::HIR::TypeRef::new_borrow(::HIR::BorrowType::Shared, node.m_value->m_res_type.clone()));
-                break;
-            case ::HIR::ExprNode_UniOp::Op::RefMut:
-                this->context.equate_types(node.span(), node.m_res_type, ::HIR::TypeRef::new_borrow(::HIR::BorrowType::Unique, node.m_value->m_res_type.clone()));
-                break;
             case ::HIR::ExprNode_UniOp::Op::Invert:
                 this->context.equate_types_assoc(node.span(), node.m_res_type,  this->context.m_crate.get_lang_item_path(node.span(), "not"), {}, node.m_value->m_res_type.clone(), "Output", true);
                 break;
@@ -669,6 +662,16 @@ namespace {
             }
             node.m_value->visit( *this );
         }
+        void visit(::HIR::ExprNode_Borrow& node) override
+        {
+            TRACE_FUNCTION_F(&node << " &_ ...");
+            this->context.add_ivars( node.m_value->m_res_type );
+            
+            // TODO: Can Ref/RefMut trigger coercions?
+            this->context.equate_types( node.span(), node.m_res_type,  ::HIR::TypeRef::new_borrow(node.m_type, node.m_value->m_res_type.clone()) );
+            
+            node.m_value->visit( *this );
+        }
         void visit(::HIR::ExprNode_Cast& node) override
         {
             auto _ = this->push_inner_coerce_scoped(false);
@@ -1466,6 +1469,9 @@ namespace {
         void visit(::HIR::ExprNode_UniOp& node) override {
             no_revisit(node);
         }
+        void visit(::HIR::ExprNode_Borrow& node) override {
+            no_revisit(node);
+        }
         void visit(::HIR::ExprNode_Cast& node) override {
             const auto& sp = node.span();
             const auto& tgt_ty = this->context.get_type(node.m_res_type);
@@ -1735,7 +1741,7 @@ namespace {
                     node.m_trait_used = ::HIR::ExprNode_CallValue::TraitUsed::Fn;
                     
                     auto borrow_ty = ::HIR::TypeRef::new_borrow( ::HIR::BorrowType::Shared, ty.clone() );
-                    node.m_value = ::HIR::ExprNodeP(new ::HIR::ExprNode_UniOp(sp, ::HIR::ExprNode_UniOp::Op::Ref, mv$(node.m_value)));
+                    node.m_value = ::HIR::ExprNodeP(new ::HIR::ExprNode_Borrow(sp, ::HIR::BorrowType::Shared, mv$(node.m_value)));
                     node.m_value->m_res_type = mv$(borrow_ty);
                 }
                 else if( this->context.m_resolve.find_trait_impls(node.span(), lang_FnMut, trait_pp, ty, [&](auto , auto cmp) {
@@ -1746,7 +1752,7 @@ namespace {
                     node.m_trait_used = ::HIR::ExprNode_CallValue::TraitUsed::FnMut;
                     
                     auto borrow_ty = ::HIR::TypeRef::new_borrow( ::HIR::BorrowType::Unique, ty.clone() );
-                    node.m_value = ::HIR::ExprNodeP(new ::HIR::ExprNode_UniOp(sp, ::HIR::ExprNode_UniOp::Op::RefMut, mv$(node.m_value)));
+                    node.m_value = ::HIR::ExprNodeP(new ::HIR::ExprNode_Borrow(sp, ::HIR::BorrowType::Unique, mv$(node.m_value)));
                     node.m_value->m_res_type = mv$(borrow_ty);
                 }
                 else
@@ -1906,18 +1912,17 @@ namespace {
                     case Receiver::Unique:
                     case Receiver::Owned: {
                         ::HIR::BorrowType   bt;
-                        ::HIR::ExprNode_UniOp::Op   op;
                         switch(receiver_class)
                         {
-                        case Receiver::Shared:  op = ::HIR::ExprNode_UniOp::Op::Ref;    bt = ::HIR::BorrowType::Shared; break;
-                        case Receiver::Unique:  op = ::HIR::ExprNode_UniOp::Op::RefMut; bt = ::HIR::BorrowType::Unique; break;
+                        case Receiver::Shared:  bt = ::HIR::BorrowType::Shared; break;
+                        case Receiver::Unique:  bt = ::HIR::BorrowType::Unique; break;
                         case Receiver::Owned:   TODO(sp, "Construct &move uni-op");
                         default:    throw "";
                         }
                         // - Add correct borrow operation
                         auto ty = ::HIR::TypeRef::new_borrow(bt, node_ptr->m_res_type.clone());
                         DEBUG("- Ref " << &*node_ptr << " -> " << ty);
-                        node_ptr = NEWNODE(mv$(ty), span, _UniOp,  op, mv$(node_ptr) );
+                        node_ptr = NEWNODE(mv$(ty), span, _Borrow,  bt, mv$(node_ptr) );
                         } break;
                     }
                 }
@@ -2984,16 +2989,13 @@ void fix_param_count(const Span& sp, Context& context, const ::HIR::GenericPath&
 namespace {
     void add_coerce_borrow(Context& context, ::HIR::ExprNodeP& node_ptr, const ::HIR::TypeRef& des_borrow_inner, ::std::function<void(::HIR::ExprNodeP& n)> cb)
     {
-        const auto& sp = node_ptr->span();
         const auto& src_type = context.m_ivars.get_type(node_ptr->m_res_type);
         
         // Since this function operates on destructured &-ptrs, the dereferences have to be added behind a borrow
         ::HIR::ExprNodeP*   node_ptr_ptr = nullptr;
         // - If the pointed node is a borrow operation, add the dereferences within its value
-        if( auto* p = dynamic_cast< ::HIR::ExprNode_UniOp*>(&*node_ptr) ) {
-            if( p->m_op == ::HIR::ExprNode_UniOp::Op::Ref || p->m_op == ::HIR::ExprNode_UniOp::Op::RefMut ) {
-                node_ptr_ptr = &p->m_value;
-            }
+        if( auto* p = dynamic_cast< ::HIR::ExprNode_Borrow*>(&*node_ptr) ) {
+            node_ptr_ptr = &p->m_value;
         }
         // - Otherwise, create a new borrow operation behind which the dereferences ahppen
         if( !node_ptr_ptr ) {
@@ -3002,22 +3004,15 @@ namespace {
             const auto& src_inner_ty = *src_type.m_data.as_Borrow().inner;
             auto borrow_type = src_type.m_data.as_Borrow().type;
             
-            ::HIR::ExprNode_UniOp::Op   op = ::HIR::ExprNode_UniOp::Op::Ref;
-            switch(borrow_type)
-            {
-            case ::HIR::BorrowType::Shared: op = ::HIR::ExprNode_UniOp::Op::Ref;    break;
-            case ::HIR::BorrowType::Unique: op = ::HIR::ExprNode_UniOp::Op::RefMut; break;
-            case ::HIR::BorrowType::Owned:  TODO(sp, "Move borrow autoderef");
-            }
             auto inner_ty_ref = ::HIR::TypeRef::new_borrow(borrow_type, des_borrow_inner.clone());
             
             // 1. Dereference (resulting in the dereferenced input type)
             node_ptr = NEWNODE(src_inner_ty.clone(), span, _Deref,  mv$(node_ptr));
             // 2. Borrow (resulting in the referenced output type)
-            node_ptr = NEWNODE(mv$(inner_ty_ref), span, _UniOp,  op, mv$(node_ptr));
+            node_ptr = NEWNODE(mv$(inner_ty_ref), span, _Borrow,  borrow_type, mv$(node_ptr));
             
             // - Set node pointer reference to point into the new borrow op
-            node_ptr_ptr = &dynamic_cast< ::HIR::ExprNode_UniOp&>(*node_ptr).m_value;
+            node_ptr_ptr = &dynamic_cast< ::HIR::ExprNode_Borrow&>(*node_ptr).m_value;
         }
         else {
             auto borrow_type = context.m_ivars.get_type(node_ptr->m_res_type).m_data.as_Borrow().type;
@@ -3402,12 +3397,10 @@ namespace {
                     auto span = node_ptr->span();
                     // *<inner>
                     DEBUG("- Deref -> " << *l_e.inner);
-                    node_ptr = ::HIR::ExprNodeP(new ::HIR::ExprNode_Deref(mv$(span), mv$(node_ptr)));
-                    node_ptr->m_res_type = l_e.inner->clone();
+                    node_ptr = NEWNODE( l_e.inner->clone(), span, _Deref,  mv$(node_ptr) );
                     context.m_ivars.get_type(node_ptr->m_res_type);
                     // &*<inner>
-                    node_ptr = ::HIR::ExprNodeP(new ::HIR::ExprNode_UniOp(mv$(span), ::HIR::ExprNode_UniOp::Op::Ref, mv$(node_ptr)));
-                    node_ptr->m_res_type = ty_dst.clone();
+                    node_ptr = NEWNODE( ty_dst.clone(), span, _Borrow,  ::HIR::BorrowType::Shared, mv$(node_ptr) );
                     context.m_ivars.get_type(node_ptr->m_res_type);
                     
                     context.m_ivars.mark_change();
diff --git a/src/mir/from_hir.cpp b/src/mir/from_hir.cpp
index ba3acc51..ef0cf3a6 100644
--- a/src/mir/from_hir.cpp
+++ b/src/mir/from_hir.cpp
@@ -569,12 +569,6 @@ namespace {
             auto res = m_builder.new_temporary(node.m_res_type);
             switch(node.m_op)
             {
-            case ::HIR::ExprNode_UniOp::Op::Ref:
-                m_builder.push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_Borrow({ 0, ::HIR::BorrowType::Shared, mv$(val) }));
-                break;
-            case ::HIR::ExprNode_UniOp::Op::RefMut:
-                m_builder.push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_Borrow({ 0, ::HIR::BorrowType::Unique, mv$(val) }));
-                break;
             case ::HIR::ExprNode_UniOp::Op::Invert:
                 if( ty_val.m_data.is_Primitive() ) {
                     switch( ty_val.m_data.as_Primitive() )
@@ -622,6 +616,18 @@ namespace {
             }
             m_builder.set_result( node.span(), mv$(res) );
         }
+        void visit(::HIR::ExprNode_Borrow& node) override
+        {
+            TRACE_FUNCTION_F("_Borrow");
+            
+            const auto& ty_val = node.m_value->m_res_type;
+            this->visit_node_ptr(node.m_value);
+            auto val = m_builder.lvalue_or_temp( ty_val, m_builder.get_result(node.m_value->span()) );
+            
+            auto res = m_builder.new_temporary(node.m_res_type);
+            m_builder.push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_Borrow({ 0, node.m_type, mv$(val) }));
+            m_builder.set_result( node.span(), mv$(res) );
+        }
         void visit(::HIR::ExprNode_Cast& node) override
         {
             TRACE_FUNCTION_F("_Cast");