All - Clang warning fixes

17 files changed, 134 insertions, 73 deletions

diff --git a/Makefile b/Makefile
index 6b54750b..4a2b49ad 100644
--- a/Makefile
+++ b/Makefile
@@ -10,6 +10,7 @@ CXXFLAGS := -g -Wall -std=c++14 -Werror
 CXXFLAGS += -O2
 CPPFLAGS := -I src/include/ -I src/
 
+CXXFLAGS += -Wno-pessimizing-move
 #CXXFLAGS += -Wno-unused-private-field
 
 SHELL = bash
diff --git a/src/hir/from_ast.cpp b/src/hir/from_ast.cpp
index 7b8707a7..ebf2e2a6 100644
--- a/src/hir/from_ast.cpp
+++ b/src/hir/from_ast.cpp
@@ -762,7 +762,7 @@ namespace {
             this_trait.m_params.m_types.push_back( ::HIR::TypeRef(arg.m_name, i) );
             i ++;
         }
-        rv.m_params.m_bounds.push_back( ::HIR::GenericBound::make_TraitBound({ ::HIR::TypeRef("Self",0xFFFF), mv$(this_trait) }) );
+        rv.m_params.m_bounds.push_back( ::HIR::GenericBound::make_TraitBound({ ::HIR::TypeRef("Self",0xFFFF), { mv$(this_trait) } }) );
     }
     
     for(const auto& item : f.items())
diff --git a/src/hir/generic_params.hpp b/src/hir/generic_params.hpp
index a17f61f5..9b2e2456 100644
--- a/src/hir/generic_params.hpp
+++ b/src/hir/generic_params.hpp
@@ -39,8 +39,9 @@ TAGGED_UNION(GenericBound, Lifetime,
     );
 extern ::std::ostream& operator<<(::std::ostream& os, const GenericBound& x);
 
-struct GenericParams
+class GenericParams
 {
+public:
     ::std::vector<TypeParamDef>   m_types;
     ::std::vector< ::std::string>   m_lifetimes;
     
diff --git a/src/hir/path.hpp b/src/hir/path.hpp
index 8dd27096..4ca1a52f 100644
--- a/src/hir/path.hpp
+++ b/src/hir/path.hpp
@@ -11,7 +11,7 @@
 
 namespace HIR {
 
-class Trait;
+struct Trait;
 
 typedef ::std::function<const ::HIR::TypeRef&(const ::HIR::TypeRef&)> t_cb_resolve_type;
 enum Compare {
diff --git a/src/hir_conv/bind.cpp b/src/hir_conv/bind.cpp
index a78d0d5a..9457585c 100644
--- a/src/hir_conv/bind.cpp
+++ b/src/hir_conv/bind.cpp
@@ -328,7 +328,7 @@ namespace {
                         e.binding = ::HIR::TypeRef::TypePathBinding::make_Enum(&e3);
                         ),
                     (Trait,
-                        ty.m_data = ::HIR::TypeRef::Data::make_TraitObject({ mv$(pe), {}, {} });
+                        ty.m_data = ::HIR::TypeRef::Data::make_TraitObject({ ::HIR::TraitPath { mv$(pe), {}, {} }, {}, {} });
                         )
                     )
                     ),
diff --git a/src/hir_conv/constant_evaluation.cpp b/src/hir_conv/constant_evaluation.cpp
index af4fc18e..04f8abf6 100644
--- a/src/hir_conv/constant_evaluation.cpp
+++ b/src/hir_conv/constant_evaluation.cpp
@@ -534,11 +534,11 @@ namespace {
             m_crate(crate)
         {}
         
-        void visit_type(::HIR::TypeRef& ty)
+        void visit_type(::HIR::TypeRef& ty) override
         {
             TU_IFLET(::HIR::TypeRef::Data, ty.m_data, Array, e,
                 ::HIR::Visitor::visit_type(*e.inner);
-                assert(&*e.size != nullptr);
+                assert(e.size.get() != nullptr);
                 auto val = evaluate_constant(m_crate, *e.size);
                 if( !val.is_Integer() )
                     ERROR(e.size->span(), E0000, "Array size isn't an integer");
diff --git a/src/hir_conv/resolve_ufcs.cpp b/src/hir_conv/resolve_ufcs.cpp
index d7add7b2..f5e96598 100644
--- a/src/hir_conv/resolve_ufcs.cpp
+++ b/src/hir_conv/resolve_ufcs.cpp
@@ -77,7 +77,7 @@ namespace {
             auto _g = m_resolve.set_impl_generics(impl.m_params);
             ::HIR::Visitor::visit_type_impl(impl);
         }
-        void visit_trait_impl(const ::HIR::SimplePath& trait_path, ::HIR::TraitImpl& impl) {
+        void visit_trait_impl(const ::HIR::SimplePath& trait_path, ::HIR::TraitImpl& impl) override {
             auto _t = this->push_mod_traits( this->m_crate.get_mod_by_path(Span(), impl.m_src_module) );
             auto _g = m_resolve.set_impl_generics(impl.m_params);
             ::HIR::Visitor::visit_trait_impl(trait_path, impl);
diff --git a/src/hir_expand/closures.cpp b/src/hir_expand/closures.cpp
index 288ea035..f1a922ed 100644
--- a/src/hir_expand/closures.cpp
+++ b/src/hir_expand/closures.cpp
@@ -60,13 +60,15 @@ namespace {
             m_captures(captures)
         {
         }
-        void visit_node_ptr(::HIR::ExprNodeP& node) override {
-            const char* node_ty = typeid(*node).name();
-            TRACE_FUNCTION_FR(&*node << " " << node_ty << " : " << node->m_res_type, node_ty);
-            assert( node );
-            node->visit(*this);
+        void visit_node_ptr(::HIR::ExprNodeP& node_ptr) override {
+            assert( node_ptr );
+            auto& node = *node_ptr;
+            const char* node_ty = typeid(node).name();
+            TRACE_FUNCTION_FR(&node << " " << node_ty << " : " << node.m_res_type, node_ty);
+            node.visit(*this);
+            
             if( m_replacement ) {
-                node = mv$(m_replacement);
+                node_ptr = mv$(m_replacement);
             }
         }
         void visit(::HIR::ExprNode_Closure& node) override
@@ -771,7 +773,7 @@ namespace {
         }
         
         // NOTE: This is left here to ensure that any expressions that aren't handled by higher code cause a failure
-        void visit_expr(::HIR::ExprPtr& exp) {
+        void visit_expr(::HIR::ExprPtr& exp) override {
             BUG(Span(), "visit_expr hit in OuterVisitor");
         }
         
diff --git a/src/hir_expand/ufcs_everything.cpp b/src/hir_expand/ufcs_everything.cpp
index dbbf0b3e..17168fbd 100644
--- a/src/hir_expand/ufcs_everything.cpp
+++ b/src/hir_expand/ufcs_everything.cpp
@@ -30,7 +30,8 @@ namespace {
         {
         }
         void visit_node_ptr(::HIR::ExprPtr& root) {
-            const char* node_ty = typeid(*root).name();
+            const auto& node_ref = *root;
+            const char* node_ty = typeid(node_ref).name();
             TRACE_FUNCTION_FR(&*root << " " << node_ty << " : " << root->m_res_type, node_ty);
             root->visit(*this);
             if( m_replacement ) {
@@ -39,7 +40,8 @@ namespace {
         }
         
         void visit_node_ptr(::HIR::ExprNodeP& node) override {
-            const char* node_ty = typeid(*node).name();
+            const auto& node_ref = *node;
+            const char* node_ty = typeid(node_ref).name();
             TRACE_FUNCTION_FR(&*node << " " << node_ty << " : " << node->m_res_type, node_ty);
             assert( node );
             node->visit(*this);
@@ -170,7 +172,7 @@ namespace {
         }
         
         // NOTE: This is left here to ensure that any expressions that aren't handled by higher code cause a failure
-        void visit_expr(::HIR::ExprPtr& exp) {
+        void visit_expr(::HIR::ExprPtr& exp) override {
             BUG(Span(), "visit_expr hit in OuterVisitor");
         }
         
diff --git a/src/hir_typeck/expr_check.cpp b/src/hir_typeck/expr_check.cpp
index 75fe1430..e9ce915e 100644
--- a/src/hir_typeck/expr_check.cpp
+++ b/src/hir_typeck/expr_check.cpp
@@ -22,14 +22,14 @@ namespace {
         public ::HIR::ExprVisitor
     {
         const StaticTraitResolve&  m_resolve;
-        const t_args&   m_args;
+        //const t_args&   m_args;
         const ::HIR::TypeRef&   ret_type;
         ::std::vector< const ::HIR::TypeRef*>   closure_ret_types;
         
     public:
         ExprVisitor_Validate(const StaticTraitResolve& res, const t_args& args, const ::HIR::TypeRef& ret_type):
             m_resolve(res),
-            m_args(args),
+            //m_args(args),
             ret_type(ret_type)
         {
         }
@@ -669,7 +669,7 @@ namespace {
         {}
         
         // NOTE: This is left here to ensure that any expressions that aren't handled by higher code cause a failure
-        void visit_expr(::HIR::ExprPtr& exp) {
+        void visit_expr(::HIR::ExprPtr& exp) override {
             BUG(Span(), "visit_expr hit in OuterVisitor");
         }
         
diff --git a/src/hir_typeck/expr_cs.cpp b/src/hir_typeck/expr_cs.cpp
index 4e704f5f..7adf8be8 100644
--- a/src/hir_typeck/expr_cs.cpp
+++ b/src/hir_typeck/expr_cs.cpp
@@ -2020,12 +2020,13 @@ namespace {
             ivars(context.m_ivars)
         {
         }
-        void visit_node_ptr(::HIR::ExprNodeP& node) override {
-            const char* node_ty = typeid(*node).name();
-            TRACE_FUNCTION_FR(&node << " " << &*node << " " << node_ty << " : " << node->m_res_type, node_ty);
-            this->check_type_resolved_top(node->span(), node->m_res_type);
-            DEBUG(node_ty << " : = " << node->m_res_type);
-            ::HIR::ExprVisitorDef::visit_node_ptr(node);
+        void visit_node_ptr(::HIR::ExprNodeP& node_ptr) override {
+            auto& node = *node_ptr;
+            const char* node_ty = typeid(node).name();
+            TRACE_FUNCTION_FR(&node << " " << &node << " " << node_ty << " : " << node.m_res_type, node_ty);
+            this->check_type_resolved_top(node.span(), node.m_res_type);
+            DEBUG(node_ty << " : = " << node.m_res_type);
+            ::HIR::ExprVisitorDef::visit_node_ptr(node_ptr);
         }
         
         void visit(::HIR::ExprNode_Let& node) override {
diff --git a/src/hir_typeck/expr_simple.cpp b/src/hir_typeck/expr_simple.cpp
index c4fdfdbf..3d5f4e2b 100644
--- a/src/hir_typeck/expr_simple.cpp
+++ b/src/hir_typeck/expr_simple.cpp
@@ -100,8 +100,9 @@ namespace typeck {
         {
         }
         
-        void visit_node_ptr(::std::unique_ptr< ::HIR::ExprNode>& node_ptr) {
-            TRACE_FUNCTION_FR(typeid(*node_ptr).name(), node_ptr->m_res_type << " = " << this->context.get_type(node_ptr->m_res_type));
+        void visit_node_ptr(::std::unique_ptr< ::HIR::ExprNode>& node_ptr) override {
+            const auto& node = *node_ptr;
+            TRACE_FUNCTION_FR(typeid(node).name(), node.m_res_type << " = " << this->context.get_type(node.m_res_type));
             ::HIR::ExprVisitorDef::visit_node_ptr(node_ptr);
         }
         void visit_node(::HIR::ExprNode& node) override {
@@ -344,7 +345,7 @@ namespace typeck {
         {
         }
         
-        void visit_node_ptr(::std::unique_ptr< ::HIR::ExprNode>& node_ptr) {
+        void visit_node_ptr(::std::unique_ptr< ::HIR::ExprNode>& node_ptr) override {
             m_node_ptr_ptr = &node_ptr;
             ::HIR::ExprVisitorDef::visit_node_ptr(node_ptr);
             m_node_ptr_ptr = nullptr;
@@ -1895,12 +1896,13 @@ namespace typeck {
             context(context)
         {
         }
-        void visit_node_ptr(::HIR::ExprNodeP& node) override {
-            const char* node_ty = typeid(*node).name();
-            TRACE_FUNCTION_FR(node_ty << " : " << node->m_res_type, node_ty);
-            this->check_type_resolved(node->span(), node->m_res_type, node->m_res_type);
-            DEBUG(node_ty << " : = " << node->m_res_type);
-            ::HIR::ExprVisitorDef::visit_node_ptr(node);
+        void visit_node_ptr(::HIR::ExprNodeP& node_ptr) override {
+            auto& node = *node_ptr;
+            const char* node_ty = typeid(node).name();
+            TRACE_FUNCTION_FR(node_ty << " : " << node.m_res_type, node_ty);
+            this->check_type_resolved(node.span(), node.m_res_type, node.m_res_type);
+            DEBUG(node_ty << " : = " << node.m_res_type);
+            ::HIR::ExprVisitorDef::visit_node_ptr(node_ptr);
         }
         
     private:
diff --git a/src/hir_typeck/expr_visit.cpp b/src/hir_typeck/expr_visit.cpp
index 60066ef8..2427f44f 100644
--- a/src/hir_typeck/expr_visit.cpp
+++ b/src/hir_typeck/expr_visit.cpp
@@ -31,7 +31,7 @@ namespace {
         }
         
         // NOTE: This is left here to ensure that any expressions that aren't handled by higher code cause a failure
-        void visit_expr(::HIR::ExprPtr& exp) {
+        void visit_expr(::HIR::ExprPtr& exp) override {
             TODO(Span(), "visit_expr");
         }
 
diff --git a/src/hir_typeck/outer.cpp b/src/hir_typeck/outer.cpp
index 12a61944..2bcb7228 100644
--- a/src/hir_typeck/outer.cpp
+++ b/src/hir_typeck/outer.cpp
@@ -605,7 +605,7 @@ namespace {
             
             m_self_types.pop_back();
         }
-        void visit_marker_impl(const ::HIR::SimplePath& trait_path, ::HIR::MarkerImpl& impl)
+        void visit_marker_impl(const ::HIR::SimplePath& trait_path, ::HIR::MarkerImpl& impl) override
         {
             TRACE_FUNCTION_F("impl " << trait_path << " for " << impl.m_type << " { }");
             auto _ = m_resolve.set_impl_generics(impl.m_params);
diff --git a/src/mir/from_hir.cpp b/src/mir/from_hir.cpp
index 3787f4aa..b2858946 100644
--- a/src/mir/from_hir.cpp
+++ b/src/mir/from_hir.cpp
@@ -228,40 +228,39 @@ namespace {
                 }
                 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 this variant isn't yet processed, add a new subtree for it
                 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);
-                    }
+                    assert( it->second.is_Subtree() );
                 }
                 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 {
+                    if( it->second.is_Terminal() ) {
                         BUG(sp, "Duplicate terminal rule - " << it->second.as_Terminal());
                     }
+                    assert( !it->second.is_Unset() );
+                    assert( it->second.is_Subtree() );
+                }
+                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 = Branch( box$(DecisionTreeNode()) );
+                        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);
                 }
                 }),
             (Value,
@@ -551,7 +550,6 @@ namespace {
                 }
                 
                 this->visit_node_ptr(node.m_nodes.back());
-                //auto ret = m_builder.get_result(node.m_nodes.back()->span());
                 
                 auto bd = mv$( m_block_stack.back() );
                 m_block_stack.pop_back();
@@ -565,11 +563,11 @@ namespace {
                     }
                 }
                 
-                //m_builder.set_result(node.span(), mv$(ret));
+                // Result maintained from last node
             }
             else
             {
-                TODO(node.span(), "Lower empty blocks");
+                m_builder.set_result(node.span(), ::MIR::RValue::make_Tuple({}));
             }
         }
         void visit(::HIR::ExprNode_Return& node) override
@@ -989,6 +987,7 @@ namespace {
                                 ),
                             (Enum,
                                 const auto& enum_path = e.path.m_data.as_Generic();
+                                ASSERT_BUG(sp, node.m_branches.is_Variant(), "Tree for enum isn't a Variant - node="<<node);
                                 const auto& branches = node.m_branches.as_Variant();
                                 const auto& variants = pbe->m_variants;
                                 auto variant_count = pbe->m_variants.size();
@@ -1162,13 +1161,65 @@ namespace {
             
             if( node.m_op != ::HIR::ExprNode_Assign::Op::None )
             {
-                // TODO: What about += on primitives?
-                ASSERT_BUG(sp, node.m_op == ::HIR::ExprNode_Assign::Op::None, "Operator overload assignments should already be eliminated");
+                ASSERT_BUG(sp, node.m_slot->m_res_type == node.m_value->m_res_type, "Types must match for op-assign");
+                
+                TU_IFLET(::HIR::TypeRef::Data, node.m_slot->m_res_type.m_data, Primitive, e,
+                    switch(e)
+                    {
+                    case ::HIR::CoreType::Char:
+                    case ::HIR::CoreType::Str:
+                    case ::HIR::CoreType::Bool:
+                        BUG(sp, "Unsupported type for op-assign - " << node.m_slot->m_res_type);
+                        break;
+                    default:
+                        // Good.
+                        break;
+                    }
+                )
+                else {
+                    BUG(sp, "Unsupported type for op-assign - " << node.m_slot->m_res_type);
+                }
+                
+                auto val_lv = m_builder.lvalue_or_temp( node.m_value->m_res_type, mv$(val) );
+                
+                ::MIR::RValue res;
+                #define _(v)    ::HIR::ExprNode_Assign::Op::v
+                ::MIR::eBinOp   op;
+                switch(node.m_op)
+                {
+                case _(None):  throw "";
+                case _(Add): op = ::MIR::eBinOp::ADD; if(0)
+                case _(Sub): op = ::MIR::eBinOp::SUB; if(0)
+                case _(Mul): op = ::MIR::eBinOp::MUL; if(0)
+                case _(Div): op = ::MIR::eBinOp::DIV; if(0)
+                    ;
+                    // TODO: Overflow check
+                    res = ::MIR::RValue::make_BinOp({ dst.clone(), op, mv$(val_lv) });
+                    break;
+                case _(Mod):
+                    res = ::MIR::RValue::make_BinOp({ dst.clone(), ::MIR::eBinOp::MOD, mv$(val_lv) });
+                    break;
+                case _(Xor): op = ::MIR::eBinOp::BIT_XOR; if(0)
+                case _(Or ): op = ::MIR::eBinOp::BIT_OR ; if(0)
+                case _(And): op = ::MIR::eBinOp::BIT_AND; if(0)
+                    ;
+                    res = ::MIR::RValue::make_BinOp({ dst.clone(), op, mv$(val_lv) });
+                    break;
+                case _(Shl): op = ::MIR::eBinOp::BIT_SHL; if(0)
+                case _(Shr): op = ::MIR::eBinOp::BIT_SHR; if(0)
+                    ;
+                    // TODO: Overflow check
+                    res = ::MIR::RValue::make_BinOp({ dst.clone(), op, mv$(val_lv) });
+                    break;
+                }
+                
+                m_builder.push_stmt_assign(mv$(dst), mv$(res));
             }
             else
             {
                 m_builder.push_stmt_assign(mv$(dst), mv$(val));
             }
+            m_builder.set_result(node.span(), ::MIR::RValue::make_Tuple({}));
         }
         
         void visit(::HIR::ExprNode_BinOp& node) override
@@ -1616,7 +1667,7 @@ namespace {
         {}
         
         // NOTE: This is left here to ensure that any expressions that aren't handled by higher code cause a failure
-        void visit_expr(::HIR::ExprPtr& exp) {
+        void visit_expr(::HIR::ExprPtr& exp) override {
             BUG(Span(), "visit_expr hit in OuterVisitor");
         }
         
diff --git a/src/mir/mir.hpp b/src/mir/mir.hpp
index 59e2b316..52f17a7d 100644
--- a/src/mir/mir.hpp
+++ b/src/mir/mir.hpp
@@ -175,8 +175,9 @@ struct BasicBlock
 };
 
 
-struct Function
+class Function
 {
+public:
     ::std::vector< ::HIR::TypeRef>  named_variables;
     ::std::vector< ::HIR::TypeRef>  temporaries;
     
diff --git a/src/resolve/absolute.cpp b/src/resolve/absolute.cpp
index a21c9b10..abfaa672 100644
--- a/src/resolve/absolute.cpp
+++ b/src/resolve/absolute.cpp
@@ -111,7 +111,7 @@ struct Context
     }
     
     class RootBlockScope {
-        friend class Context;
+        friend struct Context;
         Context& ctxt;
         unsigned int old_varcount;
         RootBlockScope(Context& ctxt, unsigned int val):