MIR - Match construction draft, cleanup

3 files changed, 410 insertions, 142 deletions

diff --git a/src/include/tagged_union.hpp b/src/include/tagged_union.hpp
index e392815e..1e319b08 100644
--- a/src/include/tagged_union.hpp
+++ b/src/include/tagged_union.hpp
@@ -204,7 +204,7 @@ class _name TU_EXP _inherit { \
     Tag m_tag; \
     union DataUnion { TU_UNION_FIELDS _variants DataUnion() {} ~DataUnion() {} } m_data;/*
 */ public:\
-    _name(): m_tag(TAG_##_def) { m_data._def = TU_DATANAME(_def)(); }/*
+    _name(): m_tag(TAG_##_def) { new (&m_data._def) TU_DATANAME(_def)(); }/*
 */  _name(const _name&) = delete;/*
 */  _name(_name&& x) noexcept: m_tag(x.m_tag) TU_EXP _extra_move { switch(m_tag) { case TAGDEAD: break; TU_MOVE_CASES _variants } x.m_tag = TAGDEAD; }/*
 */  _name& operator =(_name&& x) { switch(m_tag) { case TAGDEAD: break; TU_DEST_CASES _variants } m_tag = x.m_tag; TU_EXP _extra_assign switch(m_tag) { case TAGDEAD: break; TU_MOVE_CASES _variants }; return *this; }/*
diff --git a/src/main.cpp b/src/main.cpp
index d13ec346..adea74f5 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -33,6 +33,8 @@ bool debug_enabled()
     //return g_cur_phase != "Parse" && g_cur_phase != "Expand";

     //return g_cur_phase != "Parse" && g_cur_phase != "Expand" && g_cur_phase != "Resolve";

     return g_cur_phase != "Parse" && g_cur_phase != "Expand" && g_cur_phase != "Resolve" && g_cur_phase != "Typecheck Expressions";

+    //return false;

+    //return g_cur_phase == "Lower MIR";

 }

 ::std::ostream& debug_output(int indent, const char* function)

 {

diff --git a/src/mir/from_hir.cpp b/src/mir/from_hir.cpp
index 4b663879..c8d909e3 100644
--- a/src/mir/from_hir.cpp
+++ b/src/mir/from_hir.cpp
@@ -16,8 +16,7 @@
 #include "main_bindings.hpp"
 
 namespace {
-    class ExprVisitor_Conv:
-        public ::HIR::ExprVisitor
+    class MirBuilder
     {
         ::MIR::Function&    m_output;
         
@@ -26,25 +25,13 @@ namespace {
         
         ::MIR::RValue   m_result;
         bool    m_result_valid;
-        
-        struct LoopDesc {
-            ::std::string   label;
-            unsigned int    cur;
-            unsigned int    next;
-        };
-        ::std::vector<LoopDesc> m_loop_stack;
-        struct BlockDesc {
-            ::std::vector<unsigned int> bindings;
-        };
-        ::std::vector<BlockDesc>    m_block_stack;
-        
     public:
-        ExprVisitor_Conv(::MIR::Function& output):
+        MirBuilder(::MIR::Function& output):
             m_output(output),
             m_block_active(false),
             m_result_valid(false)
         {
-            this->set_cur_block( this->new_bb_unlinked() );
+            set_cur_block( new_bb_unlinked() );
         }
         
         ::MIR::LValue new_temporary(const ::HIR::TypeRef& ty)
@@ -59,8 +46,8 @@ namespace {
                 return mv$(e);
             )
             else {
-                auto temp = this->new_temporary(ty);
-                this->push_stmt_assign( ::MIR::LValue(temp.as_Temporary()), mv$(val) );
+                auto temp = new_temporary(ty);
+                push_stmt_assign( ::MIR::LValue(temp.as_Temporary()), mv$(val) );
                 return temp;
             }
         }
@@ -91,6 +78,9 @@ namespace {
             m_result = mv$(val);
             m_result_valid = true;
         }
+        bool has_result() const {
+            return m_result_valid;
+        }
         
         void push_stmt_assign(::MIR::LValue dst, ::MIR::RValue val)
         {
@@ -103,6 +93,9 @@ namespace {
             m_output.blocks.at(m_current_block).statements.push_back( ::MIR::Statement::make_Drop({ ::MIR::eDropKind::DEEP, mv$(val) }) );
         }
         
+        bool block_active() const {
+            return m_block_active;
+        }
         void end_block(::MIR::Terminator term)
         {
             if( !m_block_active ) {
@@ -123,8 +116,8 @@ namespace {
         ::MIR::BasicBlockId new_bb_linked()
         {
             auto rv = new_bb_unlinked();
-            this->end_block( ::MIR::Terminator::make_Goto(rv) );
-            this->set_cur_block(rv);
+            end_block( ::MIR::Terminator::make_Goto(rv) );
+            set_cur_block(rv);
             return rv;
         }
         ::MIR::BasicBlockId new_bb_unlinked()
@@ -133,13 +126,37 @@ namespace {
             m_output.blocks.push_back({});
             return rv;
         }
+    };
+    
+    class ExprVisitor_Conv:
+        public ::HIR::ExprVisitor
+    {
+        MirBuilder  m_builder;
+        
+        struct LoopDesc {
+            ::std::string   label;
+            unsigned int    cur;
+            unsigned int    next;
+        };
+        ::std::vector<LoopDesc> m_loop_stack;
+        struct BlockDesc {
+            ::std::vector<unsigned int> bindings;
+        };
+        ::std::vector<BlockDesc>    m_block_stack;
+        
+    public:
+        ExprVisitor_Conv(::MIR::Function& output):
+            m_builder(output)
+        {
+        }
+        
         
         void destructure_from(const Span& sp, const ::HIR::Pattern& pat, ::MIR::LValue lval)
         {
             if( pat.m_binding.is_valid() ) {
                 ASSERT_BUG(sp, pat.m_data.is_Any(), "Destructure patterns can't bind and match");
                 
-                this->push_stmt_assign( ::MIR::LValue::make_Variable(pat.m_binding.m_slot), mv$(lval) );
+                m_builder.push_stmt_assign( ::MIR::LValue::make_Variable(pat.m_binding.m_slot), mv$(lval) );
                 return ;
             }
             // TODO: Destructure
@@ -159,21 +176,21 @@ namespace {
                     auto& subnode = node.m_nodes[i];
                     const Span& sp = subnode->span();
                     this->visit_node_ptr(subnode);
-                    this->push_stmt_drop( this->lvalue_or_temp(subnode->m_res_type, this->get_result(sp)) );
+                    m_builder.push_stmt_drop( m_builder.lvalue_or_temp(subnode->m_res_type, m_builder.get_result(sp)) );
                 }
                 
                 this->visit_node_ptr(node.m_nodes.back());
-                auto ret = this->get_result(node.m_nodes.back()->span());
+                auto ret = m_builder.get_result(node.m_nodes.back()->span());
                 
                 auto bd = mv$( m_block_stack.back() );
                 m_block_stack.pop_back();
                 
                 // Drop all bindings introduced during this block.
                 for( auto& var_idx : bd.bindings ) {
-                    this->push_stmt_drop( ::MIR::LValue::make_Variable(var_idx) );
+                    m_builder.push_stmt_drop( ::MIR::LValue::make_Variable(var_idx) );
                 }
                 
-                this->set_result(node.span(), mv$(ret));
+                m_builder.set_result(node.span(), mv$(ret));
             }
             else
             {
@@ -185,8 +202,8 @@ namespace {
             TRACE_FUNCTION_F("_Return");
             this->visit_node_ptr(node.m_value);
             
-            this->push_stmt_assign( ::MIR::LValue::make_Return({}),  this->get_result(node.span()) );
-            this->end_block( ::MIR::Terminator::make_Return({}) );
+            m_builder.push_stmt_assign( ::MIR::LValue::make_Return({}),  m_builder.get_result(node.span()) );
+            m_builder.end_block( ::MIR::Terminator::make_Return({}) );
         }
         void visit(::HIR::ExprNode_Let& node) override
         {
@@ -195,22 +212,22 @@ namespace {
             {
                 this->visit_node_ptr(node.m_value);
                 
-                this->destructure_from(node.span(), node.m_pattern, this->lvalue_or_temp(node.m_type, this->get_result(node.span()) ));
+                this->destructure_from(node.span(), node.m_pattern, m_builder.lvalue_or_temp(node.m_type, m_builder.get_result(node.span()) ));
             }
-            this->set_result(node.span(), ::MIR::RValue::make_Tuple({}));
+            m_builder.set_result(node.span(), ::MIR::RValue::make_Tuple({}));
         }
         void visit(::HIR::ExprNode_Loop& node) override
         {
             TRACE_FUNCTION_F("_Loop");
-            auto loop_block = this->new_bb_linked();
-            auto loop_next = this->new_bb_unlinked();
+            auto loop_block = m_builder.new_bb_linked();
+            auto loop_next = m_builder.new_bb_unlinked();
             
             m_loop_stack.push_back( LoopDesc { node.m_label, loop_block, loop_next } );
             this->visit_node_ptr(node.m_code);
             m_loop_stack.pop_back();
             
-            this->end_block( ::MIR::Terminator::make_Goto(loop_block) );
-            this->set_cur_block(loop_next);
+            m_builder.end_block( ::MIR::Terminator::make_Goto(loop_block) );
+            m_builder.set_cur_block(loop_next);
         }
         void visit(::HIR::ExprNode_LoopControl& node) override
         {
@@ -229,10 +246,10 @@ namespace {
             }
             
             if( node.m_continue ) {
-                this->end_block( ::MIR::Terminator::make_Goto(target_block->cur) );
+                m_builder.end_block( ::MIR::Terminator::make_Goto(target_block->cur) );
             }
             else {
-                this->end_block( ::MIR::Terminator::make_Goto(target_block->next) );
+                m_builder.end_block( ::MIR::Terminator::make_Goto(target_block->next) );
             }
         }
         
@@ -240,7 +257,7 @@ namespace {
         {
             TRACE_FUNCTION_F("_Match");
             this->visit_node_ptr(node.m_value);
-            auto match_val = this->lvalue_or_temp(node.m_value->m_res_type, this->get_result(node.m_value->span()));
+            auto match_val = m_builder.lvalue_or_temp(node.m_value->m_res_type, m_builder.get_result(node.m_value->span()));
             
             if( node.m_arms.size() == 0 ) {
                 // Nothing
@@ -467,8 +484,9 @@ namespace {
                 
                 // Map of arm index to ruleset
                 ::std::vector< ::std::pair< unsigned int, PatternRuleset > >   arm_rules;
-                for(const auto& arm : node.m_arms) {
-                    auto idx = m_arm_rules.size();
+                for(unsigned int idx = 0; idx < node.m_arms.size(); idx ++)
+                {
+                    const auto& arm = node.m_arms[idx];
                     for( const auto& pat : arm.m_patterns )
                     {
                         auto builder = PatternRulesetBuilder {};
@@ -488,36 +506,284 @@ namespace {
                 
                 // Generate arm code
                 // - End the current block with a jump to the descision code (TODO: Can this be avoided while still being defensive?)
-                auto descision_block = this->new_bb_unlinked();
-                this->end_block( ::MIR::Terminator::Goto(descision_block) );
+                auto descision_block = m_builder.new_bb_unlinked();
+                m_builder.end_block( ::MIR::Terminator::make_Goto(descision_block) );
                 
                 // - Create a result and next block
-                auto result_val = this->new_temporary(node.m_res_type);
-                auto next_block = this->new_bb_unlinked();
+                auto result_val = m_builder.new_temporary(node.m_res_type);
+                auto next_block = m_builder.new_bb_unlinked();
                 
                 // - Generate code for arms.
                 ::std::vector< ::MIR::BasicBlockId> arm_blocks;
                 arm_blocks.reserve( arm_rules.size() );
                 for(unsigned int i = 0; i < arm_rules.size(); i ++)
                 {
-                    const auto& arm = node.m_arms[i];
-                    arm_blocks.push_back( this->new_bb_unlinked() );
-                    this->set_cur_block(arm_blocks.back());
+                    auto& arm = node.m_arms[i];
+                    // TODO: Register introduced bindings to be dropped on return/diverge
+                    arm_blocks.push_back( m_builder.new_bb_unlinked() );
+                    m_builder.set_cur_block(arm_blocks.back());
                     
                     this->visit_node_ptr(arm.m_code);
                     
-                    this->push_stmt_assign( result_val.clone(), this->get_result(arm.m_code->span()) );
-                    // TODO: Drop unused bindings introduced by this arm.
-                    this->end_block( ::MIR::Terminator::Goto(next_block) );
+                    if( !m_builder.block_active() && !m_builder.has_result() ) {
+                        // Nothing need be done, as the block diverged.
+                    }
+                    else {
+                        m_builder.push_stmt_assign( result_val.clone(), m_builder.get_result(arm.m_code->span()) );
+                        m_builder.end_block( ::MIR::Terminator::make_Goto(next_block) );
+                    }
+                }
+                
+                // ## Create descision tree in-memory based off the ruleset
+                // > Tree contains an lvalue and a set of possibilities (PatternRule) connected to another tree or to a branch index
+                struct DecisionTreeNode {
+                    TAGGED_UNION( Branch, Unset,
+                    (Unset, struct{}),
+                    (Subtree, ::std::unique_ptr<DecisionTreeNode>),
+                    (Terminal, unsigned int)
+                    );
+                    
+                    TAGGED_UNION( Values, Unset,
+                    (Unset, struct {}),
+                    (Variant, ::std::vector< ::std::pair<unsigned int, Branch> >)/*,
+                    (Unsigned, struct { branchset_t<uint64_t[2]>    branches; }),
+                    (String, struct { branchset_t< ::std::string>   branches; })*/
+                    );
+                    
+                    bool is_specialisation;
+                    ::MIR::LValue   value;
+                    Values  m_branches;
+                    Branch  m_default;
+                    
+                    DecisionTreeNode():
+                        is_specialisation(false)
+                    {}
+                    
+                    void populate_tree_from_rule(const Span& sp, unsigned int arm_index, const PatternRule* first_rule, unsigned int rule_count)
+                    {
+                        populate_tree_from_rule(sp, first_rule, rule_count, [rule_count](auto& branch){ branch = Branch::make_Terminal(rule_count); });
+                    }
+                    // `and_then` - Closure called after processing the final rule
+                    void populate_tree_from_rule(const Span& sp, const PatternRule* first_rule, unsigned int rule_count, ::std::function<void(Branch&)> and_then)
+                    {
+                        assert( rule_count > 0 );
+                        const auto& rule = *first_rule;
+                        
+                        TU_MATCHA( (rule), (e),
+                        (Any, {
+                            if( m_default.is_Unset() ) {
+                                if( rule_count == 1 ) {
+                                    and_then(m_default);
+                                }
+                                else {
+                                    auto be = box$(DecisionTreeNode());
+                                    be->populate_tree_from_rule(sp, first_rule+1, rule_count-1, and_then);
+                                    m_default = Branch(mv$(be));
+                                }
+                            }
+                            else TU_IFLET( Branch, m_default, Subtree, be,
+                                assert( be );
+                                assert(rule_count > 1);
+                                be->populate_tree_from_rule(sp, first_rule+1, rule_count-1, and_then);
+                            )
+                            else {
+                                // NOTE: All lists processed as part of the same tree should be the same length
+                                BUG(sp, "Duplicate terminal rule");
+                            }
+                            }),
+                        (Variant, {
+                            if( m_branches.is_Unset() ) {
+                                m_branches = Values::make_Variant({});
+                            }
+                            if( !m_branches.is_Variant() ) {
+                                BUG(sp, "Mismatched rules");
+                            }
+                            auto& be = m_branches.as_Variant();
+                            auto it = ::std::find_if( be.begin(), be.end(), [&](const auto& x){ return x.first >= e.idx; });
+                            // Not found? Insert a new branch
+                            if( it == be.end() || it->first != e.idx ) {
+                                it = be.insert(it, ::std::make_pair(e.idx, Branch( box$(DecisionTreeNode()) )));
+                                auto& subtree = *it->second.as_Subtree();
+                                
+                                if( e.sub_rules.size() > 0 && rule_count > 1 )
+                                {
+                                    subtree.populate_tree_from_rule(sp, e.sub_rules.data(), e.sub_rules.size(), [&](auto& branch){
+                                        ASSERT_BUG(sp, branch.is_Unset(), "Duplicate terminator");
+                                        branch.as_Subtree()->populate_tree_from_rule(sp, first_rule+1, rule_count-1, and_then);
+                                        });
+                                }
+                                else if( e.sub_rules.size() > 0)
+                                {
+                                    subtree.populate_tree_from_rule(sp, e.sub_rules.data(), e.sub_rules.size(), and_then);
+                                }
+                                else if( rule_count > 1 )
+                                {
+                                    subtree.populate_tree_from_rule(sp, first_rule+1, rule_count-1, and_then);
+                                }
+                                else
+                                {
+                                    and_then(it->second);
+                                }
+                            }
+                            else {
+                                assert( !it->second.is_Unset() );
+                                TU_IFLET(Branch, it->second, Subtree, subtree_ptr,
+                                    assert(subtree_ptr);
+                                    subtree_ptr->populate_tree_from_rule(sp, first_rule+1, rule_count-1, and_then);
+                                )
+                                else {
+                                    BUG(sp, "Duplicate terminal rule - " << it->second.as_Terminal());
+                                }
+                            }
+                            }),
+                        (Value,
+                            TODO(sp, "Value patterns");
+                            )
+                        )
+                    }
+                    
+                    /*
+                    void populate_tree_vals(const ::HIR::TypeRef& ty, unsigned int ty_ofs, const ::MIR::LValue& val)
+                    {
+                        TU_MATCHA( (ty.m_data), (e),
+                        (
+                        (Infer,   BUG(sp, "Ivar for in match type"); ),
+                        (Diverge, BUG(sp, "Diverge in match type");  ),
+                        (Primitive,
+                            TODO(sp, "Primitive");
+                            ),
+                        (Tuple,
+                            if( ty_ofs == 0 && e.size() == 0 ) {
+                            }
+                            else {
+                                assert(ty_ofs < e.size());
+                                populate_tree_from_rule( e[ty_ofs], 0, ::MIR::LValue::make_Field({ box$(val.clone()), FMT(ty_ofs)}), arm_index, first_rule, rule_count );
+                            }
+                            // Tuple - Recurse on each sub-type (increasing the index)
+                            for(unsigned int i = 0; i < e.size(); i ++) {
+                                idx += this->create_match_tree(sp, view, idx, e[i]);
+                            }
+                            ),
+                        (Path,
+                            // This is either a struct destructure or an enum
+                            TU_MATCHA( (e.binding), (pbe),
+                            (Unbound,
+                                BUG(sp, "Encounterd unbound path - " << e.path);
+                                ),
+                            (Opaque,
+                                // TODO: Why did this push a pattern? There's no chance of fail.
+                                return 1;
+                                ),
+                            (Struct,
+                                TODO(sp, "Match over struct - " << e.path);
+                                ),
+                            (Enum,
+                                auto variant_count = pbe->m_variants.size();
+                                auto first_any = variant_count;
+                                for( unsigned int i = 0; i < view.rule_count(); i ++ ) {
+                                    if( view.get(i, idx).is_Any() ) {
+                                        first_any = i;
+                                        break;
+                                    }
+                                }
+                                auto any_block = (first_any < variant_count ? m_builder.new_bb_unlinked() : 0);
+                                
+                                // Emit a switch over the variant
+                                ::std::vector< ::MIR::BasicBlockId> variants;
+                                variants.reserve( pbe->m_variants.size() );
+                                for( unsigned int i = 0; i < view.rule_count(); i ++ ) {
+                                    const auto& pat = view.get(i, idx);
+                                    if( pat.is_Any() ) {
+                                        break ;
+                                    }
+                                    else TU_IFLET( PatternRule, pat, Variant, e ) {
+                                        if( variants.size() == e.idx + 1 ) {
+                                            // Repeated index, will be unified later?
+                                        }
+                                        else {
+                                            if( variants.size() != e.idx ) {
+                                                assert( variants.size() < e.idx );
+                                                if( ! has_any ) {
+                                                    ERROR(sp, E0000, "Non-exhaustive match, variant " << pbe->m_variants[variants.size()].first << " missing");
+                                                }
+                                                variants.resize( e.idx, any_block );
+                                            }
+                                            variants.push_back( m_builder.new_bb_unlinked() );
+                                        }
+                                    }
+                                    else {
+                                        BUG(sp, "Encountered unexpected pattern rule in enum, arm " << i);
+                                    }
+                                }
+                                if( variants.size() != variant_count )
+                                {
+                                    if( ! has_any ) {
+                                        ERROR(sp, E0000, "Non-exhaustive match, variant " << pbe->m_variants[variants.size()].first << " missing");
+                                    }
+                                    variants.resize( e.idx, any_block );
+                                }
+                                
+                                m_builder.end_block( ::MIR::Terminator::make_Switch({
+                                    view.get_lvalue(idx), mv$(variants)
+                                    }) );
+                                
+                                
+                                // Enums consume one rule
+                                return 1;
+                                )
+                            )
+                            ),
+                        (Generic,
+                            // TODO: Why did this push a pattern? There's no chance of fail.
+                            return 1;
+                            ),
+                        (TraitObject,
+                            ERROR(sp, E0000, "Attempting to match over a trait object");
+                            ),
+                        (Array,
+                            // TODO: Slice patterns, sequential comparison/sub-match
+                            TODO(sp, "Match over array");
+                            ),
+                        (Slice,
+                            BUG(sp, "Hit match over `[T]` - must be `&[T]`");
+                            ),
+                        (Borrow,
+                            TU_MATCH_DEF( ::HIR::Pattern::Data, (pat.m_data), (pe),
+                            ( throw ""; ),
+                            (Any,
+                                this->append_from( sp, pat, *e.inner );
+                                ),
+                            (Ref,
+                                this->append_from( sp, *pe.sub, *e.inner );
+                                )
+                            )
+                            ),
+                        (Pointer,
+                            ERROR(sp, E0000, "Attempting to match over a pointer");
+                            ),
+                        (Function,
+                            ERROR(sp, E0000, "Attempting to match over a functon pointer");
+                            ),
+                        (Closure,
+                            ERROR(sp, E0000, "Attempting to match over a closure");
+                            )
+                        )
+                    }
+                    */
+                };
+                
+                // - Build tree by running each arm's pattern across it
+                DecisionTreeNode    root_node;
+                for( const auto& arm_rule : arm_rules )
+                {
+                    root_node.populate_tree_from_rule( node.m_arms[arm_rule.first].m_code->span(), arm_rule.first, arm_rule.second.m_rules.data(), arm_rule.second.m_rules.size() );
                 }
-
-                // Generate decision code based on ruleset and type
-                this->set_cur_block(descision_block);
                 
-                TODO(node.span(), "Convert match into MIR using ruleset");
+                // TODO: Convert the above decision tree into MIR
+                TODO(node.span(), "Turn decision tree into MIR");
                 
-                this->set_cur_block(next_block);
-                this->set_result( mv$(result_val) );
+                m_builder.set_cur_block(next_block);
+                m_builder.set_result( node.span(), mv$(result_val) );
             }
         } // ExprNode_Match
         
@@ -526,36 +792,36 @@ namespace {
             TRACE_FUNCTION_F("_If");
             
             this->visit_node_ptr(node.m_cond);
-            auto decision_val = this->lvalue_or_temp(node.m_cond->m_res_type, this->get_result(node.m_cond->span()) );
+            auto decision_val = m_builder.lvalue_or_temp(node.m_cond->m_res_type, m_builder.get_result(node.m_cond->span()) );
             
-            auto true_branch = this->new_bb_unlinked();
-            auto false_branch = this->new_bb_unlinked();
-            auto next_block = this->new_bb_unlinked();
-            this->end_block( ::MIR::Terminator::make_If({ mv$(decision_val), true_branch, false_branch }) );
+            auto true_branch = m_builder.new_bb_unlinked();
+            auto false_branch = m_builder.new_bb_unlinked();
+            auto next_block = m_builder.new_bb_unlinked();
+            m_builder.end_block( ::MIR::Terminator::make_If({ mv$(decision_val), true_branch, false_branch }) );
             
-            auto result_val = this->new_temporary(node.m_res_type);
+            auto result_val = m_builder.new_temporary(node.m_res_type);
             
-            this->set_cur_block(true_branch);
+            m_builder.set_cur_block(true_branch);
             this->visit_node_ptr(node.m_true);
-            this->push_stmt_assign( result_val.clone(), this->get_result(node.m_true->span()) );
-            this->end_block( ::MIR::Terminator::make_Goto(next_block) );
+            m_builder.push_stmt_assign( result_val.clone(), m_builder.get_result(node.m_true->span()) );
+            m_builder.end_block( ::MIR::Terminator::make_Goto(next_block) );
             
-            this->set_cur_block(false_branch);
+            m_builder.set_cur_block(false_branch);
             if( node.m_false )
             {
                 this->visit_node_ptr(node.m_false);
-                this->push_stmt_assign( result_val.clone(), this->get_result(node.m_false->span()) );
-                this->end_block( ::MIR::Terminator::make_Goto(next_block) );
+                m_builder.push_stmt_assign( result_val.clone(), m_builder.get_result(node.m_false->span()) );
+                m_builder.end_block( ::MIR::Terminator::make_Goto(next_block) );
             }
             else
             {
                 // Assign `()` to the result
-                this->push_stmt_assign( result_val.clone(), ::MIR::RValue::make_Tuple({}) );
-                this->end_block( ::MIR::Terminator::make_Goto(next_block) );
+                m_builder.push_stmt_assign( result_val.clone(), ::MIR::RValue::make_Tuple({}) );
+                m_builder.end_block( ::MIR::Terminator::make_Goto(next_block) );
             }
-            this->set_cur_block(next_block);
+            m_builder.set_cur_block(next_block);
             
-            this->set_result( node.span(), mv$(result_val) );
+            m_builder.set_result( node.span(), mv$(result_val) );
         }
         
         void visit(::HIR::ExprNode_Assign& node) override
@@ -564,10 +830,10 @@ namespace {
             const auto& sp = node.span();
             
             this->visit_node_ptr(node.m_value);
-            auto val = this->get_result(sp);
+            auto val = m_builder.get_result(sp);
             
             this->visit_node_ptr(node.m_slot);
-            auto dst = this->get_result_lvalue(sp);
+            auto dst = m_builder.get_result_lvalue(sp);
             
             if( node.m_op != ::HIR::ExprNode_Assign::Op::None )
             {
@@ -576,7 +842,7 @@ namespace {
             }
             else
             {
-                this->push_stmt_assign(mv$(dst), mv$(val));
+                m_builder.push_stmt_assign(mv$(dst), mv$(val));
             }
         }
         
@@ -584,12 +850,12 @@ namespace {
         {
             TRACE_FUNCTION_F("_BinOp");
             this->visit_node_ptr(node.m_left);
-            auto left = this->lvalue_or_temp( node.m_left->m_res_type, this->get_result(node.m_left->span()) );
+            auto left = m_builder.lvalue_or_temp( node.m_left->m_res_type, m_builder.get_result(node.m_left->span()) );
             
             this->visit_node_ptr(node.m_right);
-            auto right = this->lvalue_or_temp( node.m_right->m_res_type, this->get_result(node.m_right->span()) );
+            auto right = m_builder.lvalue_or_temp( node.m_right->m_res_type, m_builder.get_result(node.m_right->span()) );
             
-            auto res = this->new_temporary(node.m_res_type);
+            auto res = m_builder.new_temporary(node.m_res_type);
             ::MIR::eBinOp   op;
             switch(node.m_op)
             {
@@ -599,19 +865,19 @@ namespace {
             case ::HIR::ExprNode_BinOp::Op::CmpLtE: op = ::MIR::eBinOp::LE; if(0)
             case ::HIR::ExprNode_BinOp::Op::CmpGt:  op = ::MIR::eBinOp::GT; if(0)
             case ::HIR::ExprNode_BinOp::Op::CmpGtE: op = ::MIR::eBinOp::GE;
-                this->push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_BinOp({ mv$(left), op, mv$(right) }));
+                m_builder.push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_BinOp({ mv$(left), op, mv$(right) }));
                 break;
             
             case ::HIR::ExprNode_BinOp::Op::Xor: op = ::MIR::eBinOp::BIT_XOR; if(0)
             case ::HIR::ExprNode_BinOp::Op::Or : op = ::MIR::eBinOp::BIT_OR ; if(0)
             case ::HIR::ExprNode_BinOp::Op::And: op = ::MIR::eBinOp::BIT_AND;
-                this->push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_BinOp({ mv$(left), op, mv$(right) }));
+                m_builder.push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_BinOp({ mv$(left), op, mv$(right) }));
                 break;
             
             case ::HIR::ExprNode_BinOp::Op::Shr: op = ::MIR::eBinOp::BIT_SHR; if(0)
             case ::HIR::ExprNode_BinOp::Op::Shl: op = ::MIR::eBinOp::BIT_SHL;
                 // TODO: Overflow checks
-                this->push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_BinOp({ mv$(left), op, mv$(right) }));
+                m_builder.push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_BinOp({ mv$(left), op, mv$(right) }));
                 break;
             
             case ::HIR::ExprNode_BinOp::Op::BoolAnd:
@@ -627,41 +893,41 @@ namespace {
             case ::HIR::ExprNode_BinOp::Op::Div:    op = ::MIR::eBinOp::DIV; if(0)
             case ::HIR::ExprNode_BinOp::Op::Mod:    op = ::MIR::eBinOp::MOD;
                 // TODO: Overflow checks
-                this->push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_BinOp({ mv$(left), op, mv$(right) }));
+                m_builder.push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_BinOp({ mv$(left), op, mv$(right) }));
                 break;
             }
-            this->set_result( node.span(), mv$(res) );
+            m_builder.set_result( node.span(), mv$(res) );
         }
         
         void visit(::HIR::ExprNode_UniOp& node) override
         {
             TRACE_FUNCTION_F("_UniOp");
             this->visit_node_ptr(node.m_value);
-            auto val = this->lvalue_or_temp( node.m_value->m_res_type, this->get_result(node.m_value->span()) );
+            auto val = m_builder.lvalue_or_temp( node.m_value->m_res_type, m_builder.get_result(node.m_value->span()) );
             
-            auto res = this->new_temporary(node.m_res_type);
+            auto res = m_builder.new_temporary(node.m_res_type);
             switch(node.m_op)
             {
             case ::HIR::ExprNode_UniOp::Op::Ref:
-                this->push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_Borrow({ 0, ::HIR::BorrowType::Shared, mv$(val) }));
+                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:
-                this->push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_Borrow({ 0, ::HIR::BorrowType::Unique, mv$(val) }));
+                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:
-                this->push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_UniOp({ mv$(val), ::MIR::eUniOp::INV }));
+                m_builder.push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_UniOp({ mv$(val), ::MIR::eUniOp::INV }));
                 break;
             case ::HIR::ExprNode_UniOp::Op::Negate:
-                this->push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_UniOp({ mv$(val), ::MIR::eUniOp::NEG }));
+                m_builder.push_stmt_assign(res.as_Temporary(), ::MIR::RValue::make_UniOp({ mv$(val), ::MIR::eUniOp::NEG }));
                 break;
             }
-            this->set_result( node.span(), mv$(res) );
+            m_builder.set_result( node.span(), mv$(res) );
         }
         void visit(::HIR::ExprNode_Cast& node) override
         {
             TRACE_FUNCTION_F("_Cast");
             this->visit_node_ptr(node.m_value);
-            auto val = this->lvalue_or_temp( node.m_value->m_res_type, this->get_result(node.m_value->span()) );
+            auto val = m_builder.lvalue_or_temp( node.m_value->m_res_type, m_builder.get_result(node.m_value->span()) );
             
             #if 0
             TU_MATCH_DEF( ::HIR::TypeRef::Data, (node.m_res_type->m_data), (de),
@@ -675,9 +941,9 @@ namespace {
                 )
             )
             #endif
-            auto res = this->new_temporary(node.m_res_type);
-            this->push_stmt_assign(res.clone(), ::MIR::RValue::make_Cast({ mv$(val), node.m_res_type.clone() }));
-            this->set_result( node.span(), mv$(res) );
+            auto res = m_builder.new_temporary(node.m_res_type);
+            m_builder.push_stmt_assign(res.clone(), ::MIR::RValue::make_Cast({ mv$(val), node.m_res_type.clone() }));
+            m_builder.set_result( node.span(), mv$(res) );
         }
         void visit(::HIR::ExprNode_Unsize& node) override
         {
@@ -689,10 +955,10 @@ namespace {
         {
             TRACE_FUNCTION_F("_Index");
             this->visit_node_ptr(node.m_index);
-            auto index = this->lvalue_or_temp( node.m_index->m_res_type, this->get_result(node.m_index->span()) );
+            auto index = m_builder.lvalue_or_temp( node.m_index->m_res_type, m_builder.get_result(node.m_index->span()) );
             
             this->visit_node_ptr(node.m_value);
-            auto value = this->lvalue_or_temp( node.m_value->m_res_type, this->get_result(node.m_value->span()) );
+            auto value = m_builder.lvalue_or_temp( node.m_value->m_res_type, m_builder.get_result(node.m_value->span()) );
             
             if( false )
             {
@@ -709,32 +975,32 @@ namespace {
                     )
                 )
                 
-                auto limit_lval = this->lvalue_or_temp(node.m_index->m_res_type, mv$(limit_val));
+                auto limit_lval = m_builder.lvalue_or_temp(node.m_index->m_res_type, mv$(limit_val));
                 
-                auto cmp_res = this->new_temporary( ::HIR::CoreType::Bool );
-                this->push_stmt_assign(cmp_res.clone(), ::MIR::RValue::make_BinOp({ index.clone(), ::MIR::eBinOp::GE, mv$(limit_lval) }));
-                auto arm_panic = this->new_bb_unlinked();
-                auto arm_continue = this->new_bb_unlinked();
-                this->end_block( ::MIR::Terminator::make_If({ mv$(cmp_res), arm_panic, arm_continue }) );
+                auto cmp_res = m_builder.new_temporary( ::HIR::CoreType::Bool );
+                m_builder.push_stmt_assign(cmp_res.clone(), ::MIR::RValue::make_BinOp({ index.clone(), ::MIR::eBinOp::GE, mv$(limit_lval) }));
+                auto arm_panic = m_builder.new_bb_unlinked();
+                auto arm_continue = m_builder.new_bb_unlinked();
+                m_builder.end_block( ::MIR::Terminator::make_If({ mv$(cmp_res), arm_panic, arm_continue }) );
                 
-                this->set_cur_block( arm_panic );
+                m_builder.set_cur_block( arm_panic );
                 // TODO: Call an "index fail" method which always panics.
-                //this->end_block( ::MIR::Terminator::make_Panic({}) );
-                this->end_block( ::MIR::Terminator::make_Diverge({}) );
+                //m_builder.end_block( ::MIR::Terminator::make_Panic({}) );
+                m_builder.end_block( ::MIR::Terminator::make_Diverge({}) );
                 
-                this->set_cur_block( arm_continue );
+                m_builder.set_cur_block( arm_continue );
             }
             
-            this->set_result( node.span(), ::MIR::LValue::make_Index({ box$(index), box$(value) }) );
+            m_builder.set_result( node.span(), ::MIR::LValue::make_Index({ box$(index), box$(value) }) );
         }
         
         void visit(::HIR::ExprNode_Deref& node) override
         {
             TRACE_FUNCTION_F("_Deref");
             this->visit_node_ptr(node.m_value);
-            auto val = this->lvalue_or_temp( node.m_value->m_res_type, this->get_result(node.m_value->span()) );
+            auto val = m_builder.lvalue_or_temp( node.m_value->m_res_type, m_builder.get_result(node.m_value->span()) );
             
-            this->set_result( node.span(), ::MIR::LValue::make_Deref({ box$(val) }) );
+            m_builder.set_result( node.span(), ::MIR::LValue::make_Deref({ box$(val) }) );
         }
         
         void visit(::HIR::ExprNode_TupleVariant& node) override
@@ -745,10 +1011,10 @@ namespace {
             for(auto& arg : node.m_args)
             {
                 this->visit_node_ptr(arg);
-                values.push_back( this->lvalue_or_temp( arg->m_res_type, this->get_result(arg->span()) ) );
+                values.push_back( m_builder.lvalue_or_temp( arg->m_res_type, m_builder.get_result(arg->span()) ) );
             }
             
-            this->set_result( node.span(), ::MIR::RValue::make_Struct({
+            m_builder.set_result( node.span(), ::MIR::RValue::make_Struct({
                 node.m_path.clone(),
                 mv$(values)
                 }) );
@@ -762,7 +1028,7 @@ namespace {
             for(auto& arg : node.m_args)
             {
                 this->visit_node_ptr(arg);
-                values.push_back( this->lvalue_or_temp( arg->m_res_type, this->get_result(arg->span()) ) );
+                values.push_back( m_builder.lvalue_or_temp( arg->m_res_type, m_builder.get_result(arg->span()) ) );
             }
             
             // TODO: Obtain function type for this function
@@ -776,24 +1042,24 @@ namespace {
             {
                 fcn_ty_data.m_arg_types.push_back( node.m_cache.m_arg_types[i].clone() );
             }
-            auto fcn_val = this->new_temporary( ::HIR::TypeRef(mv$(fcn_ty_data)) );
-            this->push_stmt_assign( fcn_val.clone(), ::MIR::RValue::make_Constant( ::MIR::Constant(node.m_path.clone()) ) );
+            auto fcn_val = m_builder.new_temporary( ::HIR::TypeRef(mv$(fcn_ty_data)) );
+            m_builder.push_stmt_assign( fcn_val.clone(), ::MIR::RValue::make_Constant( ::MIR::Constant(node.m_path.clone()) ) );
             
-            auto panic_block = this->new_bb_unlinked();
-            auto next_block = this->new_bb_unlinked();
-            auto res = this->new_temporary( node.m_res_type );
-            this->end_block(::MIR::Terminator::make_Call({
+            auto panic_block = m_builder.new_bb_unlinked();
+            auto next_block = m_builder.new_bb_unlinked();
+            auto res = m_builder.new_temporary( node.m_res_type );
+            m_builder.end_block(::MIR::Terminator::make_Call({
                 next_block, panic_block,
                 res.clone(), mv$(fcn_val),
                 mv$(values)
                 }));
             
-            this->set_cur_block(panic_block);
+            m_builder.set_cur_block(panic_block);
             // TODO: Proper panic handling
-            this->end_block( ::MIR::Terminator::make_Diverge({}) );
+            m_builder.end_block( ::MIR::Terminator::make_Diverge({}) );
             
-            this->set_cur_block( next_block );
-            this->set_result( node.span(), mv$(res) );
+            m_builder.set_cur_block( next_block );
+            m_builder.set_result( node.span(), mv$(res) );
         }
         
         void visit(::HIR::ExprNode_CallValue& node) override
@@ -808,7 +1074,7 @@ namespace {
         {
             TRACE_FUNCTION_F("_Field");
             this->visit_node_ptr(node.m_value);
-            auto val = this->get_result_lvalue(node.m_value->span());
+            auto val = m_builder.get_result_lvalue(node.m_value->span());
             
             unsigned int idx;
             if( '0' <= node.m_field[0] && node.m_field[0] <= '9' ) {
@@ -819,7 +1085,7 @@ namespace {
                 const auto& fields = str.m_data.as_Named();
                 idx = ::std::find_if( fields.begin(), fields.end(), [&](const auto& x){ return x.first == node.m_field; } ) - fields.begin();
             }
-            this->set_result( node.span(), ::MIR::LValue::make_Field({ box$(val), idx }) );
+            m_builder.set_result( node.span(), ::MIR::LValue::make_Field({ box$(val), idx }) );
         }
         void visit(::HIR::ExprNode_Literal& node) override
         {
@@ -833,38 +1099,38 @@ namespace {
                 case ::HIR::CoreType::U32:
                 case ::HIR::CoreType::U64:
                 case ::HIR::CoreType::Usize:
-                    this->set_result(node.span(), ::MIR::RValue( ::MIR::Constant(e.m_value) ));
+                    m_builder.set_result(node.span(), ::MIR::RValue( ::MIR::Constant(e.m_value) ));
                     break;
                 case ::HIR::CoreType::I8:
                 case ::HIR::CoreType::I16:
                 case ::HIR::CoreType::I32:
                 case ::HIR::CoreType::I64:
                 case ::HIR::CoreType::Isize:
-                    this->set_result(node.span(), ::MIR::RValue( ::MIR::Constant( static_cast<int64_t>(e.m_value) ) ));
+                    m_builder.set_result(node.span(), ::MIR::RValue( ::MIR::Constant( static_cast<int64_t>(e.m_value) ) ));
                     break;
                 default:
                     BUG(node.span(), "Integer literal with unexpected type - " << node.m_res_type);
                 }
                 ),
             (Float,
-                this->set_result(node.span(), ::MIR::RValue::make_Constant( ::MIR::Constant(e.m_value) ));
+                m_builder.set_result(node.span(), ::MIR::RValue::make_Constant( ::MIR::Constant(e.m_value) ));
                 ),
             (Boolean,
-                this->set_result(node.span(), ::MIR::RValue::make_Constant( ::MIR::Constant(e) ));
+                m_builder.set_result(node.span(), ::MIR::RValue::make_Constant( ::MIR::Constant(e) ));
                 ),
             (String,
-                this->set_result(node.span(), ::MIR::RValue::make_Constant( ::MIR::Constant(e) ));
+                m_builder.set_result(node.span(), ::MIR::RValue::make_Constant( ::MIR::Constant(e) ));
                 ),
             (ByteString,
                 auto v = mv$( *reinterpret_cast< ::std::vector<uint8_t>*>( &e) );
-                this->set_result(node.span(), ::MIR::RValue::make_Constant( ::MIR::Constant(mv$(v)) ));
+                m_builder.set_result(node.span(), ::MIR::RValue::make_Constant( ::MIR::Constant(mv$(v)) ));
                 )
             )
         }
         void visit(::HIR::ExprNode_UnitVariant& node) override
         {
             TRACE_FUNCTION_F("_UnitVariant");
-            this->set_result( node.span(), ::MIR::RValue::make_Struct({
+            m_builder.set_result( node.span(), ::MIR::RValue::make_Struct({
                 node.m_path.clone(),
                 {}
                 }) );
@@ -872,12 +1138,12 @@ namespace {
         void visit(::HIR::ExprNode_PathValue& node) override
         {
             TRACE_FUNCTION_F("_PathValue - " << node.m_path);
-            this->set_result( node.span(), ::MIR::LValue::make_Static(node.m_path.clone()) );
+            m_builder.set_result( node.span(), ::MIR::LValue::make_Static(node.m_path.clone()) );
         }
         void visit(::HIR::ExprNode_Variable& node) override
         {
             TRACE_FUNCTION_F("_Variable - " << node.m_name << " #" << node.m_slot);
-            this->set_result( node.span(), ::MIR::LValue::make_Variable(node.m_slot) );
+            m_builder.set_result( node.span(), ::MIR::LValue::make_Variable(node.m_slot) );
         }
         
         void visit(::HIR::ExprNode_StructLiteral& node) override
@@ -887,7 +1153,7 @@ namespace {
             if( node.m_base_value )
             {
                 this->visit_node_ptr(node.m_base_value);
-                base_val = this->get_result_lvalue(node.m_base_value->span());
+                base_val = m_builder.get_result_lvalue(node.m_base_value->span());
             }
             
             const ::HIR::t_struct_fields* fields_ptr = nullptr;
@@ -919,7 +1185,7 @@ namespace {
                 assert( !values_set[idx] );
                 values_set[idx] = true;
                 this->visit_node_ptr(ent.second);
-                values.at(idx) = this->lvalue_or_temp( ent.second->m_res_type, this->get_result(ent.second->span()) );
+                values.at(idx) = m_builder.lvalue_or_temp( ent.second->m_res_type, m_builder.get_result(ent.second->span()) );
             }
             for(unsigned int i = 0; i < values.size(); i ++)
             {
@@ -932,12 +1198,12 @@ namespace {
                 else {
                     // Drop unused part of the base
                     if( node.m_base_value) {
-                        this->push_stmt_drop( ::MIR::LValue::make_Field({ box$( base_val.clone() ), i }) );
+                        m_builder.push_stmt_drop( ::MIR::LValue::make_Field({ box$( base_val.clone() ), i }) );
                     }
                 }
             }
             
-            this->set_result( node.span(), ::MIR::RValue::make_Struct({
+            m_builder.set_result( node.span(), ::MIR::RValue::make_Struct({
                 node.m_path.clone(),
                 mv$(values)
                 }) );
@@ -951,10 +1217,10 @@ namespace {
             for(auto& arg : node.m_vals)
             {
                 this->visit_node_ptr(arg);
-                values.push_back( this->lvalue_or_temp( arg->m_res_type, this->get_result(arg->span()) ) );
+                values.push_back( m_builder.lvalue_or_temp( arg->m_res_type, m_builder.get_result(arg->span()) ) );
             }
             
-            this->set_result( node.span(), ::MIR::RValue::make_Tuple({
+            m_builder.set_result( node.span(), ::MIR::RValue::make_Tuple({
                 mv$(values)
                 }) );
         }
@@ -967,10 +1233,10 @@ namespace {
             for(auto& arg : node.m_vals)
             {
                 this->visit_node_ptr(arg);
-                values.push_back( this->lvalue_or_temp( arg->m_res_type, this->get_result(arg->span()) ) );
+                values.push_back( m_builder.lvalue_or_temp( arg->m_res_type, m_builder.get_result(arg->span()) ) );
             }
             
-            this->set_result( node.span(), ::MIR::RValue::make_Array({
+            m_builder.set_result( node.span(), ::MIR::RValue::make_Array({
                 mv$(values)
                 }) );
         }
@@ -979,9 +1245,9 @@ namespace {
         {
             TRACE_FUNCTION_F("_ArraySized");
             this->visit_node_ptr( node.m_val );
-            auto value = this->lvalue_or_temp( node.m_val->m_res_type, this->get_result(node.m_val->span()) );
+            auto value = m_builder.lvalue_or_temp( node.m_val->m_res_type, m_builder.get_result(node.m_val->span()) );
             
-            this->set_result( node.span(), ::MIR::RValue::make_SizedArray({
+            m_builder.set_result( node.span(), ::MIR::RValue::make_SizedArray({
                 mv$(value),
                 static_cast<unsigned int>(node.m_size_val)
                 }) );