Misc - Warning tweaks to make MSVC be quiet

6 files changed, 38 insertions, 36 deletions

diff --git a/src/hir_conv/constant_evaluation.cpp b/src/hir_conv/constant_evaluation.cpp
index 47c6aaee..050fa4b4 100644
--- a/src/hir_conv/constant_evaluation.cpp
+++ b/src/hir_conv/constant_evaluation.cpp
@@ -462,14 +462,14 @@ namespace HIR {
 
                 ::HIR::Literal  val;
                 const auto& sa = stmt.as_Assign();
-                TU_MATCHA( (sa.src), (e),
-                (Use,
+                TU_MATCH_HDRA( (sa.src), {)
+                TU_ARMA(Use, e) {
                     val = local_state.read_lval(e);
-                    ),
-                (Constant,
+                    }
+                TU_ARMA(Constant, e) {
                     val = const_to_lit(e);
-                    ),
-                (SizedArray,
+                    }
+                TU_ARMA(SizedArray, e) {
                     ::std::vector< ::HIR::Literal>  vals;
                     if( e.count > 0 )
                     {
@@ -480,8 +480,8 @@ namespace HIR {
                         vals.push_back( mv$(val) );
                     }
                     val = ::HIR::Literal::make_List( mv$(vals) );
-                    ),
-                (Borrow,
+                    }
+                TU_ARMA(Borrow, e) {
                     if( e.type != ::HIR::BorrowType::Shared ) {
                         MIR_BUG(state, "Only shared borrows are allowed in constants");
                     }
@@ -508,8 +508,8 @@ namespace HIR {
                         auto item_path = this->nvs.new_static( mv$(inner_ty), mv$(inner_val) );
                         val = ::HIR::Literal::make_BorrowPath( mv$(item_path) );
                     }
-                    ),
-                (Cast,
+                    }
+                TU_ARMA(Cast, e) {
                     auto inval = local_state.read_lval(e.val);
                     if( inval.is_Defer() ) {
                         val = ::HIR::Literal::make_Defer({});
@@ -592,8 +592,8 @@ namespace HIR {
                         }
                         )
                     )
-                    ),
-                (BinOp,
+                    }
+                TU_ARMA(BinOp, e) {
                     auto inval_l = read_param(e.val_l);
                     auto inval_r = read_param(e.val_r);
                     if( inval_l.is_Defer() || inval_r.is_Defer() )
@@ -661,8 +661,8 @@ namespace HIR {
                         }
                         )
                     )
-                    ),
-                (UniOp,
+                    }
+                TU_ARMA(UniOp, e) {
                     auto inval = local_state.read_lval(e.val);
                     if( inval.is_Defer() )
                         return ::HIR::Literal::make_Defer({});
@@ -673,7 +673,7 @@ namespace HIR {
                             val = ::HIR::Literal( ~i );
                             break;
                         case ::MIR::eUniOp::NEG:
-                            val = ::HIR::Literal( -i );
+                            val = ::HIR::Literal( static_cast<uint64_t>(-static_cast<int64_t>(i)) );
                             break;
                         }
                     )
@@ -691,14 +691,14 @@ namespace HIR {
                     else {
                         MIR_BUG(state, "Invalid invert of " << inval.tag_str());
                     }
-                    ),
-                (DstMeta,
+                    }
+                TU_ARMA(DstMeta, e) {
                     MIR_TODO(state, "RValue::DstMeta");
-                    ),
-                (DstPtr,
+                    }
+                TU_ARMA(DstPtr, e) {
                     MIR_TODO(state, "RValue::DstPtr");
-                    ),
-                (MakeDst,
+                    }
+                TU_ARMA(MakeDst, e) {
                     auto ptr = read_param(e.ptr_val);
                     if(ptr.is_Defer()) return ::HIR::Literal::make_Defer({});
                     auto meta = read_param(e.meta_val);
@@ -709,8 +709,8 @@ namespace HIR {
                     else {
                         val = mv$(ptr);
                     }
-                    ),
-                (Tuple,
+                    }
+                TU_ARMA(Tuple, e) {
                     ::std::vector< ::HIR::Literal>  vals;
                     vals.reserve( e.vals.size() );
                     for(const auto& v : e.vals) {
@@ -720,8 +720,8 @@ namespace HIR {
                         }
                     }
                     val = ::HIR::Literal::make_List( mv$(vals) );
-                    ),
-                (Array,
+                    }
+                TU_ARMA(Array, e) {
                     ::std::vector< ::HIR::Literal>  vals;
                     vals.reserve( e.vals.size() );
                     for(const auto& v : e.vals) {
@@ -731,13 +731,13 @@ namespace HIR {
                         }
                     }
                     val = ::HIR::Literal::make_List( mv$(vals) );
-                    ),
-                (Variant,
+                    }
+                TU_ARMA(Variant, e) {
                     auto ival = read_param(e.val);
                     if(ival.is_Defer()) return ::HIR::Literal::make_Defer({});
                     val = ::HIR::Literal::make_Variant({ e.index, box$(ival) });
-                    ),
-                (Struct,
+                    }
+                TU_ARMA(Struct, e) {
                     ::std::vector< ::HIR::Literal>  vals;
                     vals.reserve( e.vals.size() );
                     for(const auto& v : e.vals) {
@@ -747,8 +747,8 @@ namespace HIR {
                         }
                     }
                     val = ::HIR::Literal::make_List( mv$(vals) );
-                    )
-                )
+                    }
+                }
 
                 auto& dst = local_state.get_lval(sa.dst);
                 dst = mv$(val);
diff --git a/src/hir_typeck/expr_cs.cpp b/src/hir_typeck/expr_cs.cpp
index 0eb20568..431dc2f9 100644
--- a/src/hir_typeck/expr_cs.cpp
+++ b/src/hir_typeck/expr_cs.cpp
@@ -1275,7 +1275,7 @@ namespace {
             }
 
             const ::HIR::t_struct_fields* fields_ptr = nullptr;
-            const ::HIR::GenericParams* generics;
+            const ::HIR::GenericParams* generics = nullptr;
             TU_MATCH(::HIR::TypeRef::TypePathBinding, (ty.m_data.as_Path().binding), (e),
             (Unbound, ),
             (Opaque, ),
@@ -1322,6 +1322,7 @@ namespace {
                 )
             )
             ASSERT_BUG(node.span(), fields_ptr, "");
+            assert(generics);
             const ::HIR::t_struct_fields& fields = *fields_ptr;
 
             const auto& ty_params = ty_path.m_params.m_types;
diff --git a/src/mir/mir_builder.cpp b/src/mir/mir_builder.cpp
index 96833609..8a64e380 100644
--- a/src/mir/mir_builder.cpp
+++ b/src/mir/mir_builder.cpp
@@ -1946,7 +1946,7 @@ VarState& MirBuilder::get_slot_state_mut(const Span& sp, unsigned int idx, SlotT
 VarState* MirBuilder::get_val_state_mut_p(const Span& sp, const ::MIR::LValue& lv, bool expect_valid/*=false*/)
 {
     TRACE_FUNCTION_F(lv);
-    VarState*   vs;
+    VarState*   vs = nullptr;
     TU_MATCHA( (lv.m_root), (e),
     (Return,
         BUG(sp, "Move of return value");
@@ -1963,6 +1963,7 @@ VarState* MirBuilder::get_val_state_mut_p(const Span& sp, const ::MIR::LValue& l
         //BUG(sp, "Attempting to mutate state of a static");
         )
     )
+    assert(vs);
 
     if( expect_valid && vs->is_Valid() )
     {
diff --git a/src/parse/pattern.cpp b/src/parse/pattern.cpp
index cd73c378..53c0cfe8 100644
--- a/src/parse/pattern.cpp
+++ b/src/parse/pattern.cpp
@@ -224,7 +224,7 @@ AST::Pattern Parse_PatternReal1(TokenStream& lex, bool is_refutable)
         {
             auto dt = tok.datatype();
             // TODO: Ensure that the type is ANY or a signed integer
-            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Integer({dt, -tok.intval()}) );
+            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Integer({dt, ~tok.intval() + 1}) );
         }
         else if( tok.type() == TOK_FLOAT )
         {
diff --git a/src/parse/tokentree.hpp b/src/parse/tokentree.hpp
index 3d6e63de..1a751225 100644
--- a/src/parse/tokentree.hpp
+++ b/src/parse/tokentree.hpp
@@ -46,7 +46,7 @@ public:
     bool is_token() const {
         return m_tok.type() != TOK_NULL;
     }
-    unsigned int size() const {
+    size_t size() const {
         return m_subtrees.size();
     }
     const TokenTree& operator[](unsigned int idx) const { assert(idx < m_subtrees.size()); return m_subtrees[idx]; }
diff --git a/src/trans/target.cpp b/src/trans/target.cpp
index de5492a8..0f4c6320 100644
--- a/src/trans/target.cpp
+++ b/src/trans/target.cpp
@@ -1147,7 +1147,7 @@ namespace {
                     {
                         pow8 = ::std::max(pow8, 2);
                     }
-                    else if( -0x80000000 <= v2 && v2 < 0x80000000 )
+                    else if( -0x80000000ll <= v2 && v2 < 0x80000000ll )
                     {
                         pow8 = ::std::max(pow8, 3);
                     }