Remove inside_loop parameter from type resolution of stmts and expressions

We already have a Context object containing info about loop contexts. This
removes the need for us to pass this variable around simplifying the type
resolution code. The parameter was a hack used to support error handling
cases in Break and Continue expression's but this is no longer required.

14 files changed, 95 insertions, 122 deletions

diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc
index 13edd8d..7e87e1d 100644
--- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc
+++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc
@@ -324,8 +324,7 @@ TraitItemReference::resolve_item (HIR::TraitItemFunc &func)
   auto expected_ret_tyty = resolved_fn_type->get_return_type ();
   context->push_return_type (TypeCheckContextItem (&func), expected_ret_tyty);
 
-  auto block_expr_ty
-    = TypeCheckExpr::Resolve (func.get_block_expr ().get (), false);
+  auto block_expr_ty = TypeCheckExpr::Resolve (func.get_block_expr ().get ());
 
   context->pop_return_type ();
 
diff --git a/gcc/rust/typecheck/rust-hir-type-check-enumitem.h b/gcc/rust/typecheck/rust-hir-type-check-enumitem.h
index d6baff1..16cae9c 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-enumitem.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-enumitem.h
@@ -81,7 +81,7 @@ public:
       rust_error_at (item.get_locus (), "discriminant too big");
 
     auto &discriminant = item.get_discriminant_expression ();
-    auto capacity_type = TypeCheckExpr::Resolve (discriminant.get (), false);
+    auto capacity_type = TypeCheckExpr::Resolve (discriminant.get ());
     if (capacity_type->get_kind () == TyTy::TypeKind::ERROR)
       return;
 
diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc
index 394eee0..d96a85c 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc
@@ -56,9 +56,8 @@ TypeCheckExpr::visit (HIR::RangeFromToExpr &expr)
   // resolve the range expressions and these types must unify then we use that
   // type to substitute into the ADT
   TyTy::BaseType *from_ty
-    = TypeCheckExpr::Resolve (expr.get_from_expr ().get (), false);
-  TyTy::BaseType *to_ty
-    = TypeCheckExpr::Resolve (expr.get_to_expr ().get (), false);
+    = TypeCheckExpr::Resolve (expr.get_from_expr ().get ());
+  TyTy::BaseType *to_ty = TypeCheckExpr::Resolve (expr.get_to_expr ().get ());
   TyTy::BaseType *unified = from_ty->unify (to_ty);
 
   // substitute it in
@@ -105,7 +104,7 @@ TypeCheckExpr::visit (HIR::RangeFromExpr &expr)
   // resolve the range expressions and these types must unify then we use that
   // type to substitute into the ADT
   TyTy::BaseType *from_ty
-    = TypeCheckExpr::Resolve (expr.get_from_expr ().get (), false);
+    = TypeCheckExpr::Resolve (expr.get_from_expr ().get ());
 
   // substitute it in
   std::vector<TyTy::SubstitutionArg> subst_mappings;
@@ -150,8 +149,7 @@ TypeCheckExpr::visit (HIR::RangeToExpr &expr)
 
   // resolve the range expressions and these types must unify then we use that
   // type to substitute into the ADT
-  TyTy::BaseType *from_ty
-    = TypeCheckExpr::Resolve (expr.get_to_expr ().get (), false);
+  TyTy::BaseType *from_ty = TypeCheckExpr::Resolve (expr.get_to_expr ().get ());
 
   // substitute it in
   std::vector<TyTy::SubstitutionArg> subst_mappings;
@@ -228,9 +226,8 @@ TypeCheckExpr::visit (HIR::RangeFromToInclExpr &expr)
   // resolve the range expressions and these types must unify then we use that
   // type to substitute into the ADT
   TyTy::BaseType *from_ty
-    = TypeCheckExpr::Resolve (expr.get_from_expr ().get (), false);
-  TyTy::BaseType *to_ty
-    = TypeCheckExpr::Resolve (expr.get_to_expr ().get (), false);
+    = TypeCheckExpr::Resolve (expr.get_from_expr ().get ());
+  TyTy::BaseType *to_ty = TypeCheckExpr::Resolve (expr.get_to_expr ().get ());
   TyTy::BaseType *unified = from_ty->unify (to_ty);
 
   // substitute it in
@@ -245,12 +242,11 @@ TypeCheckExpr::visit (HIR::RangeFromToInclExpr &expr)
 void
 TypeCheckExpr::visit (HIR::ArrayIndexExpr &expr)
 {
-  auto array_expr_ty
-    = TypeCheckExpr::Resolve (expr.get_array_expr (), inside_loop);
+  auto array_expr_ty = TypeCheckExpr::Resolve (expr.get_array_expr ());
   if (array_expr_ty->get_kind () == TyTy::TypeKind::ERROR)
     return;
 
-  auto index_expr_ty = TypeCheckExpr::Resolve (expr.get_index_expr (), false);
+  auto index_expr_ty = TypeCheckExpr::Resolve (expr.get_index_expr ());
   if (index_expr_ty->get_kind () == TyTy::TypeKind::ERROR)
     return;
 
diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h
index 411d45d..d7c3da9 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-expr.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h
@@ -40,12 +40,11 @@ class TypeCheckExpr : public TypeCheckBase
   using Rust::Resolver::TypeCheckBase::visit;
 
 public:
-  /* Perform type checking on expr. Also runs type unification algorithm.
-     Returns the unified type of expr.
-     `inside_loop` acts as a context for BreakExpr, etc. May change later. */
-  static TyTy::BaseType *Resolve (HIR::Expr *expr, bool inside_loop)
+  // Perform type checking on expr. Also runs type unification algorithm.
+  // Returns the unified type of expr
+  static TyTy::BaseType *Resolve (HIR::Expr *expr)
   {
-    TypeCheckExpr resolver (inside_loop);
+    TypeCheckExpr resolver;
     expr->accept_vis (resolver);
 
     if (resolver.infered == nullptr)
@@ -66,8 +65,7 @@ public:
 
   void visit (HIR::TupleIndexExpr &expr) override
   {
-    auto resolved
-      = TypeCheckExpr::Resolve (expr.get_tuple_expr ().get (), inside_loop);
+    auto resolved = TypeCheckExpr::Resolve (expr.get_tuple_expr ().get ());
     if (resolved->get_kind () == TyTy::TypeKind::ERROR)
       {
 	rust_error_at (expr.get_tuple_expr ()->get_locus (),
@@ -154,7 +152,7 @@ public:
     std::vector<TyTy::TyVar> fields;
     for (auto &elem : expr.get_tuple_elems ())
       {
-	auto field_ty = TypeCheckExpr::Resolve (elem.get (), false);
+	auto field_ty = TypeCheckExpr::Resolve (elem.get ());
 	fields.push_back (TyTy::TyVar (field_ty->get_ref ()));
       }
     infered = new TyTy::TupleType (expr.get_mappings ().get_hirid (),
@@ -168,7 +166,7 @@ public:
 
     TyTy::BaseType *expr_ty
       = expr.has_return_expr ()
-	  ? TypeCheckExpr::Resolve (expr.get_expr (), false)
+	  ? TypeCheckExpr::Resolve (expr.get_expr ())
 	  : TyTy::TupleType::get_unit_type (expr.get_mappings ().get_hirid ());
 
     infered = fn_return_tyty->unify (expr_ty);
@@ -181,8 +179,7 @@ public:
 
   void visit (HIR::CallExpr &expr) override
   {
-    TyTy::BaseType *function_tyty
-      = TypeCheckExpr::Resolve (expr.get_fnexpr (), false);
+    TyTy::BaseType *function_tyty = TypeCheckExpr::Resolve (expr.get_fnexpr ());
 
     bool valid_tyty = function_tyty->get_kind () == TyTy::TypeKind::ADT
 		      || function_tyty->get_kind () == TyTy::TypeKind::FNDEF
@@ -225,8 +222,7 @@ public:
 
   void visit (HIR::MethodCallExpr &expr) override
   {
-    auto receiver_tyty
-      = TypeCheckExpr::Resolve (expr.get_receiver ().get (), false);
+    auto receiver_tyty = TypeCheckExpr::Resolve (expr.get_receiver ().get ());
     if (receiver_tyty->get_kind () == TyTy::TypeKind::ERROR)
       {
 	rust_error_at (expr.get_receiver ()->get_locus (),
@@ -381,8 +377,8 @@ public:
     infered
       = TyTy::TupleType::get_unit_type (expr.get_mappings ().get_hirid ());
 
-    auto lhs = TypeCheckExpr::Resolve (expr.get_lhs (), false);
-    auto rhs = TypeCheckExpr::Resolve (expr.get_rhs (), false);
+    auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+    auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
 
     auto result = lhs->coerce (rhs);
     if (result->get_kind () == TyTy::TypeKind::ERROR)
@@ -431,8 +427,8 @@ public:
     infered
       = TyTy::TupleType::get_unit_type (expr.get_mappings ().get_hirid ());
 
-    auto lhs = TypeCheckExpr::Resolve (expr.get_left_expr ().get (), false);
-    auto rhs = TypeCheckExpr::Resolve (expr.get_right_expr ().get (), false);
+    auto lhs = TypeCheckExpr::Resolve (expr.get_left_expr ().get ());
+    auto rhs = TypeCheckExpr::Resolve (expr.get_right_expr ().get ());
 
     // we dont care about the result of the unify from a compound assignment
     // since this is a unit-type expr
@@ -534,8 +530,8 @@ public:
 
   void visit (HIR::ArithmeticOrLogicalExpr &expr) override
   {
-    auto lhs = TypeCheckExpr::Resolve (expr.get_lhs (), false);
-    auto rhs = TypeCheckExpr::Resolve (expr.get_rhs (), false);
+    auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+    auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
 
     auto lang_item_type
       = Analysis::RustLangItem::OperatorToLangItem (expr.get_expr_type ());
@@ -570,8 +566,8 @@ public:
 
   void visit (HIR::ComparisonExpr &expr) override
   {
-    auto lhs = TypeCheckExpr::Resolve (expr.get_lhs (), false);
-    auto rhs = TypeCheckExpr::Resolve (expr.get_rhs (), false);
+    auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+    auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
 
     auto result = lhs->unify (rhs);
     if (result == nullptr || result->get_kind () == TyTy::TypeKind::ERROR)
@@ -583,8 +579,8 @@ public:
 
   void visit (HIR::LazyBooleanExpr &expr) override
   {
-    auto lhs = TypeCheckExpr::Resolve (expr.get_lhs (), false);
-    auto rhs = TypeCheckExpr::Resolve (expr.get_rhs (), false);
+    auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+    auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
 
     // we expect the lhs and rhs must be bools at this point
     TyTy::BoolType elhs (expr.get_mappings ().get_hirid ());
@@ -602,8 +598,7 @@ public:
 
   void visit (HIR::NegationExpr &expr) override
   {
-    auto negated_expr_ty
-      = TypeCheckExpr::Resolve (expr.get_expr ().get (), false);
+    auto negated_expr_ty = TypeCheckExpr::Resolve (expr.get_expr ().get ());
 
     // check for operator overload
     auto lang_item_type = Analysis::RustLangItem::NegationOperatorToLangItem (
@@ -664,8 +659,8 @@ public:
 
   void visit (HIR::IfExpr &expr) override
   {
-    TypeCheckExpr::Resolve (expr.get_if_condition (), false);
-    TypeCheckExpr::Resolve (expr.get_if_block (), inside_loop);
+    TypeCheckExpr::Resolve (expr.get_if_condition ());
+    TypeCheckExpr::Resolve (expr.get_if_block ());
 
     infered
       = TyTy::TupleType::get_unit_type (expr.get_mappings ().get_hirid ());
@@ -673,11 +668,9 @@ public:
 
   void visit (HIR::IfExprConseqElse &expr) override
   {
-    TypeCheckExpr::Resolve (expr.get_if_condition (), false);
-    auto if_blk_resolved
-      = TypeCheckExpr::Resolve (expr.get_if_block (), inside_loop);
-    auto else_blk_resolved
-      = TypeCheckExpr::Resolve (expr.get_else_block (), inside_loop);
+    TypeCheckExpr::Resolve (expr.get_if_condition ());
+    auto if_blk_resolved = TypeCheckExpr::Resolve (expr.get_if_block ());
+    auto else_blk_resolved = TypeCheckExpr::Resolve (expr.get_else_block ());
 
     if (if_blk_resolved->get_kind () == TyTy::NEVER)
       infered = else_blk_resolved;
@@ -689,11 +682,10 @@ public:
 
   void visit (HIR::IfExprConseqIf &expr) override
   {
-    TypeCheckExpr::Resolve (expr.get_if_condition (), false);
-    auto if_blk_resolved
-      = TypeCheckExpr::Resolve (expr.get_if_block (), inside_loop);
+    TypeCheckExpr::Resolve (expr.get_if_condition ());
+    auto if_blk_resolved = TypeCheckExpr::Resolve (expr.get_if_block ());
     auto else_blk_resolved
-      = TypeCheckExpr::Resolve (expr.get_conseq_if_expr (), inside_loop);
+      = TypeCheckExpr::Resolve (expr.get_conseq_if_expr ());
 
     if (if_blk_resolved->get_kind () == TyTy::NEVER)
       infered = else_blk_resolved;
@@ -708,7 +700,7 @@ public:
     // this needs to perform a least upper bound coercion on the blocks and then
     // unify the scruintee and arms
     TyTy::BaseType *scrutinee_tyty
-      = TypeCheckExpr::Resolve (expr.get_scrutinee_expr ().get (), false);
+      = TypeCheckExpr::Resolve (expr.get_scrutinee_expr ().get ());
 
     for (auto &pattern : expr.get_patterns ())
       {
@@ -720,7 +712,7 @@ public:
 	  return;
       }
 
-    TypeCheckExpr::Resolve (expr.get_if_block (), inside_loop);
+    TypeCheckExpr::Resolve (expr.get_if_block ());
 
     infered
       = TyTy::TupleType::get_unit_type (expr.get_mappings ().get_hirid ());
@@ -730,8 +722,7 @@ public:
 
   void visit (HIR::UnsafeBlockExpr &expr) override
   {
-    infered
-      = TypeCheckExpr::Resolve (expr.get_block_expr ().get (), inside_loop);
+    infered = TypeCheckExpr::Resolve (expr.get_block_expr ().get ());
   }
 
   void visit (HIR::ArrayIndexExpr &expr) override;
@@ -747,11 +738,10 @@ public:
 	case HIR::ArrayElems::ArrayExprType::COPIED: {
 	  HIR::ArrayElemsCopied &elems
 	    = static_cast<HIR::ArrayElemsCopied &> (elements);
-	  element_type
-	    = TypeCheckExpr::Resolve (elems.get_elem_to_copy (), false);
+	  element_type = TypeCheckExpr::Resolve (elems.get_elem_to_copy ());
 
 	  auto capacity_type
-	    = TypeCheckExpr::Resolve (elems.get_num_copies_expr (), false);
+	    = TypeCheckExpr::Resolve (elems.get_num_copies_expr ());
 
 	  TyTy::BaseType *expected_ty = nullptr;
 	  bool ok = context->lookup_builtin ("usize", &expected_ty);
@@ -774,7 +764,7 @@ public:
 	  std::vector<TyTy::BaseType *> types;
 	  for (auto &elem : elems.get_values ())
 	    {
-	      types.push_back (TypeCheckExpr::Resolve (elem.get (), false));
+	      types.push_back (TypeCheckExpr::Resolve (elem.get ()));
 	    }
 
 	  element_type = TyTy::TyVar::get_implicit_infer_var (expr.get_locus ())
@@ -813,7 +803,7 @@ public:
   void visit (HIR::StructExprStruct &struct_expr) override
   {
     TyTy::BaseType *struct_path_ty
-      = TypeCheckExpr::Resolve (&struct_expr.get_struct_name (), false);
+      = TypeCheckExpr::Resolve (&struct_expr.get_struct_name ());
     if (struct_path_ty->get_kind () != TyTy::TypeKind::ADT)
       {
 	rust_error_at (struct_expr.get_struct_name ().get_locus (),
@@ -831,13 +821,13 @@ public:
 
   void visit (HIR::GroupedExpr &expr) override
   {
-    infered = TypeCheckExpr::Resolve (expr.get_expr_in_parens ().get (), false);
+    infered = TypeCheckExpr::Resolve (expr.get_expr_in_parens ().get ());
   }
 
   void visit (HIR::FieldAccessExpr &expr) override
   {
     auto struct_base
-      = TypeCheckExpr::Resolve (expr.get_receiver_expr ().get (), false);
+      = TypeCheckExpr::Resolve (expr.get_receiver_expr ().get ());
 
     // FIXME does this require autoderef here?
     if (struct_base->get_kind () == TyTy::TypeKind::REF)
@@ -885,7 +875,7 @@ public:
     context->push_new_loop_context (expr.get_mappings ().get_hirid (),
 				    expr.get_locus ());
     TyTy::BaseType *block_expr
-      = TypeCheckExpr::Resolve (expr.get_loop_block ().get (), true);
+      = TypeCheckExpr::Resolve (expr.get_loop_block ().get ());
     if (!block_expr->is_unit ())
       {
 	rust_error_at (expr.get_loop_block ()->get_locus (),
@@ -912,9 +902,9 @@ public:
   {
     context->push_new_while_loop_context (expr.get_mappings ().get_hirid ());
 
-    TypeCheckExpr::Resolve (expr.get_predicate_expr ().get (), false);
+    TypeCheckExpr::Resolve (expr.get_predicate_expr ().get ());
     TyTy::BaseType *block_expr
-      = TypeCheckExpr::Resolve (expr.get_loop_block ().get (), true);
+      = TypeCheckExpr::Resolve (expr.get_loop_block ().get ());
 
     if (!block_expr->is_unit ())
       {
@@ -931,7 +921,7 @@ public:
 
   void visit (HIR::BreakExpr &expr) override
   {
-    if (!inside_loop)
+    if (!context->have_loop_context ())
       {
 	rust_error_at (expr.get_locus (), "cannot %<break%> outside of a loop");
 	return;
@@ -940,7 +930,7 @@ public:
     if (expr.has_break_expr ())
       {
 	TyTy::BaseType *break_expr_tyty
-	  = TypeCheckExpr::Resolve (expr.get_expr ().get (), false);
+	  = TypeCheckExpr::Resolve (expr.get_expr ().get ());
 
 	TyTy::BaseType *loop_context = context->peek_loop_context ();
 	if (loop_context->get_kind () == TyTy::TypeKind::ERROR)
@@ -959,7 +949,7 @@ public:
 
   void visit (HIR::ContinueExpr &expr) override
   {
-    if (!inside_loop)
+    if (!context->have_loop_context ())
       {
 	rust_error_at (expr.get_locus (),
 		       "cannot %<continue%> outside of a loop");
@@ -972,7 +962,7 @@ public:
   void visit (HIR::BorrowExpr &expr) override
   {
     TyTy::BaseType *resolved_base
-      = TypeCheckExpr::Resolve (expr.get_expr ().get (), false);
+      = TypeCheckExpr::Resolve (expr.get_expr ().get ());
 
     if (expr.get_is_double_borrow ())
       {
@@ -988,7 +978,7 @@ public:
   void visit (HIR::DereferenceExpr &expr) override
   {
     TyTy::BaseType *resolved_base
-      = TypeCheckExpr::Resolve (expr.get_expr ().get (), false);
+      = TypeCheckExpr::Resolve (expr.get_expr ().get ());
 
     auto lang_item_type = Analysis::RustLangItem::ItemType::DEREF;
     bool operator_overloaded
@@ -1029,7 +1019,7 @@ public:
   void visit (HIR::TypeCastExpr &expr) override
   {
     TyTy::BaseType *expr_to_convert
-      = TypeCheckExpr::Resolve (expr.get_casted_expr ().get (), false);
+      = TypeCheckExpr::Resolve (expr.get_casted_expr ().get ());
     TyTy::BaseType *tyty_to_convert_to
       = TypeCheckType::Resolve (expr.get_type_to_convert_to ().get ());
 
@@ -1041,7 +1031,7 @@ public:
     // this needs to perform a least upper bound coercion on the blocks and then
     // unify the scruintee and arms
     TyTy::BaseType *scrutinee_tyty
-      = TypeCheckExpr::Resolve (expr.get_scrutinee_expr ().get (), false);
+      = TypeCheckExpr::Resolve (expr.get_scrutinee_expr ().get ());
 
     std::vector<TyTy::BaseType *> kase_block_tys;
     for (auto &kase : expr.get_match_cases ())
@@ -1060,7 +1050,7 @@ public:
 
 	// check the kase type
 	TyTy::BaseType *kase_block_ty
-	  = TypeCheckExpr::Resolve (kase.get_expr ().get (), inside_loop);
+	  = TypeCheckExpr::Resolve (kase.get_expr ().get ());
 	kase_block_tys.push_back (kase_block_ty);
       }
 
@@ -1098,9 +1088,7 @@ protected:
 			     TyTy::BaseType *rhs);
 
 private:
-  TypeCheckExpr (bool inside_loop)
-    : TypeCheckBase (), infered (nullptr), inside_loop (inside_loop)
-  {}
+  TypeCheckExpr () : TypeCheckBase (), infered (nullptr) {}
 
   TyTy::BaseType *resolve_root_path (HIR::PathInExpression &expr,
 				     size_t *offset,
@@ -1166,8 +1154,6 @@ private:
 
   /* The return value of TypeCheckExpr::Resolve */
   TyTy::BaseType *infered;
-
-  bool inside_loop;
 };
 
 } // namespace Resolver
diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.h b/gcc/rust/typecheck/rust-hir-type-check-implitem.h
index db05505..c7af9b2 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-implitem.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.h
@@ -176,8 +176,7 @@ public:
   void visit (HIR::ConstantItem &constant) override
   {
     TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ());
-    TyTy::BaseType *expr_type
-      = TypeCheckExpr::Resolve (constant.get_expr (), false);
+    TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (constant.get_expr ());
 
     context->insert_type (constant.get_mappings (), type->unify (expr_type));
   }
@@ -369,7 +368,7 @@ public:
 			       expected_ret_tyty);
 
     auto block_expr_ty
-      = TypeCheckExpr::Resolve (function.get_definition ().get (), false);
+      = TypeCheckExpr::Resolve (function.get_definition ().get ());
 
     context->pop_return_type ();
     expected_ret_tyty->unify (block_expr_ty);
diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.h b/gcc/rust/typecheck/rust-hir-type-check-item.h
index 71b6b81..8573335 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-item.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-item.h
@@ -210,7 +210,7 @@ public:
 			       expected_ret_tyty);
 
     auto block_expr_ty
-      = TypeCheckExpr::Resolve (function.get_definition ().get (), false);
+      = TypeCheckExpr::Resolve (function.get_definition ().get ());
 
     context->pop_return_type ();
 
diff --git a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
index bceafde..be3b8e4 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc
@@ -25,13 +25,13 @@ namespace Resolver {
 void
 TypeCheckPattern::visit (HIR::PathInExpression &pattern)
 {
-  infered = TypeCheckExpr::Resolve (&pattern, false);
+  infered = TypeCheckExpr::Resolve (&pattern);
 }
 
 void
 TypeCheckPattern::visit (HIR::TupleStructPattern &pattern)
 {
-  infered = TypeCheckExpr::Resolve (&pattern.get_path (), false);
+  infered = TypeCheckExpr::Resolve (&pattern.get_path ());
   if (infered->get_kind () == TyTy::TypeKind::ERROR)
     return;
 
@@ -117,7 +117,7 @@ TypeCheckPattern::visit (HIR::TupleStructPattern &pattern)
 void
 TypeCheckPattern::visit (HIR::StructPattern &pattern)
 {
-  infered = TypeCheckExpr::Resolve (&pattern.get_path (), false);
+  infered = TypeCheckExpr::Resolve (&pattern.get_path ());
   if (infered->get_kind () == TyTy::TypeKind::ERROR)
     return;
 
@@ -300,7 +300,7 @@ TypeCheckPattern::visit (HIR::RangePattern &pattern)
 	  = *static_cast<HIR::RangePatternBoundPath *> (
 	    pattern.get_upper_bound ().get ());
 
-	upper = TypeCheckExpr::Resolve (&ref.get_path (), false);
+	upper = TypeCheckExpr::Resolve (&ref.get_path ());
       }
       break;
 
@@ -309,7 +309,7 @@ TypeCheckPattern::visit (HIR::RangePattern &pattern)
 	  = *static_cast<HIR::RangePatternBoundQualPath *> (
 	    pattern.get_upper_bound ().get ());
 
-	upper = TypeCheckExpr::Resolve (&ref.get_qualified_path (), false);
+	upper = TypeCheckExpr::Resolve (&ref.get_qualified_path ());
       }
       break;
     }
@@ -333,7 +333,7 @@ TypeCheckPattern::visit (HIR::RangePattern &pattern)
 	  = *static_cast<HIR::RangePatternBoundPath *> (
 	    pattern.get_lower_bound ().get ());
 
-	lower = TypeCheckExpr::Resolve (&ref.get_path (), false);
+	lower = TypeCheckExpr::Resolve (&ref.get_path ());
       }
       break;
 
@@ -342,7 +342,7 @@ TypeCheckPattern::visit (HIR::RangePattern &pattern)
 	  = *static_cast<HIR::RangePatternBoundQualPath *> (
 	    pattern.get_lower_bound ().get ());
 
-	lower = TypeCheckExpr::Resolve (&ref.get_qualified_path (), false);
+	lower = TypeCheckExpr::Resolve (&ref.get_qualified_path ());
       }
       break;
     }
diff --git a/gcc/rust/typecheck/rust-hir-type-check-stmt.h b/gcc/rust/typecheck/rust-hir-type-check-stmt.h
index b0ffd2a..327bffa 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-stmt.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-stmt.h
@@ -34,21 +34,21 @@ class TypeCheckStmt : public TypeCheckBase
   using Rust::Resolver::TypeCheckBase::visit;
 
 public:
-  static TyTy::BaseType *Resolve (HIR::Stmt *stmt, bool inside_loop)
+  static TyTy::BaseType *Resolve (HIR::Stmt *stmt)
   {
-    TypeCheckStmt resolver (inside_loop);
+    TypeCheckStmt resolver;
     stmt->accept_vis (resolver);
     return resolver.infered;
   }
 
   void visit (HIR::ExprStmtWithBlock &stmt) override
   {
-    infered = TypeCheckExpr::Resolve (stmt.get_expr (), inside_loop);
+    infered = TypeCheckExpr::Resolve (stmt.get_expr ());
   }
 
   void visit (HIR::ExprStmtWithoutBlock &stmt) override
   {
-    infered = TypeCheckExpr::Resolve (stmt.get_expr (), inside_loop);
+    infered = TypeCheckExpr::Resolve (stmt.get_expr ());
   }
 
   void visit (HIR::EmptyStmt &stmt) override
@@ -68,8 +68,7 @@ public:
   void visit (HIR::ConstantItem &constant) override
   {
     TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ());
-    TyTy::BaseType *expr_type
-      = TypeCheckExpr::Resolve (constant.get_expr (), false);
+    TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (constant.get_expr ());
 
     infered = type->unify (expr_type);
     context->insert_type (constant.get_mappings (), infered);
@@ -83,8 +82,7 @@ public:
     TyTy::BaseType *init_expr_ty = nullptr;
     if (stmt.has_init_expr ())
       {
-	init_expr_ty
-	  = TypeCheckExpr::Resolve (stmt.get_init_expr (), inside_loop);
+	init_expr_ty = TypeCheckExpr::Resolve (stmt.get_init_expr ());
 	if (init_expr_ty->get_kind () == TyTy::TypeKind::ERROR)
 	  return;
 
@@ -494,7 +492,7 @@ public:
 			       expected_ret_tyty);
 
     auto block_expr_ty
-      = TypeCheckExpr::Resolve (function.get_definition ().get (), false);
+      = TypeCheckExpr::Resolve (function.get_definition ().get ());
 
     context->pop_return_type ();
 
@@ -505,12 +503,9 @@ public:
   }
 
 private:
-  TypeCheckStmt (bool inside_loop)
-    : TypeCheckBase (), infered (nullptr), inside_loop (inside_loop)
-  {}
+  TypeCheckStmt () : TypeCheckBase (), infered (nullptr) {}
 
   TyTy::BaseType *infered;
-  bool inside_loop;
 };
 
 } // namespace Resolver
diff --git a/gcc/rust/typecheck/rust-hir-type-check-struct.cc b/gcc/rust/typecheck/rust-hir-type-check-struct.cc
index a1cd359..6634ad4 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-struct.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-struct.cc
@@ -28,7 +28,7 @@ void
 TypeCheckStructExpr::visit (HIR::StructExprStructFields &struct_expr)
 {
   TyTy::BaseType *struct_path_ty
-    = TypeCheckExpr::Resolve (&struct_expr.get_struct_name (), false);
+    = TypeCheckExpr::Resolve (&struct_expr.get_struct_name ());
   if (struct_path_ty->get_kind () != TyTy::TypeKind::ADT)
     {
       rust_error_at (struct_expr.get_struct_name ().get_locus (),
@@ -41,8 +41,7 @@ TypeCheckStructExpr::visit (HIR::StructExprStructFields &struct_expr)
   if (struct_expr.has_struct_base ())
     {
       TyTy::BaseType *base_resolved
-	= TypeCheckExpr::Resolve (struct_expr.struct_base->base_struct.get (),
-				  false);
+	= TypeCheckExpr::Resolve (struct_expr.struct_base->base_struct.get ());
       struct_def
 	= (TyTy::ADTType *) struct_path_resolved->coerce (base_resolved);
       if (struct_def == nullptr)
@@ -221,7 +220,7 @@ TypeCheckStructExpr::visit (HIR::StructExprFieldIdentifierValue &field)
       return;
     }
 
-  TyTy::BaseType *value = TypeCheckExpr::Resolve (field.get_value (), false);
+  TyTy::BaseType *value = TypeCheckExpr::Resolve (field.get_value ());
   resolved_field_value_expr = field_type->get_field_type ()->coerce (value);
   if (resolved_field_value_expr != nullptr)
     {
@@ -250,7 +249,7 @@ TypeCheckStructExpr::visit (HIR::StructExprFieldIndexValue &field)
       return;
     }
 
-  TyTy::BaseType *value = TypeCheckExpr::Resolve (field.get_value (), false);
+  TyTy::BaseType *value = TypeCheckExpr::Resolve (field.get_value ());
   resolved_field_value_expr = field_type->get_field_type ()->coerce (value);
   if (resolved_field_value_expr != nullptr)
     {
@@ -283,7 +282,7 @@ TypeCheckStructExpr::visit (HIR::StructExprFieldIdentifier &field)
   // existing code to figure out the type
   HIR::IdentifierExpr expr (field.get_mappings (), field.get_field_name (),
 			    field.get_locus ());
-  TyTy::BaseType *value = TypeCheckExpr::Resolve (&expr, false);
+  TyTy::BaseType *value = TypeCheckExpr::Resolve (&expr);
 
   resolved_field_value_expr = field_type->get_field_type ()->coerce (value);
   if (resolved_field_value_expr != nullptr)
diff --git a/gcc/rust/typecheck/rust-hir-type-check-toplevel.h b/gcc/rust/typecheck/rust-hir-type-check-toplevel.h
index eaa8d59..fe961d1 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-toplevel.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-toplevel.h
@@ -351,7 +351,7 @@ public:
   void visit (HIR::StaticItem &var) override
   {
     TyTy::BaseType *type = TypeCheckType::Resolve (var.get_type ());
-    TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (var.get_expr (), false);
+    TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (var.get_expr ());
 
     context->insert_type (var.get_mappings (), type->unify (expr_type));
   }
@@ -359,8 +359,7 @@ public:
   void visit (HIR::ConstantItem &constant) override
   {
     TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ());
-    TyTy::BaseType *expr_type
-      = TypeCheckExpr::Resolve (constant.get_expr (), false);
+    TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (constant.get_expr ());
 
     context->insert_type (constant.get_mappings (), type->unify (expr_type));
   }
diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc
index bd40344..85de3a1 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-type.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc
@@ -535,7 +535,7 @@ TypeCheckType::visit (HIR::TraitObjectType &type)
 void
 TypeCheckType::visit (HIR::ArrayType &type)
 {
-  auto capacity_type = TypeCheckExpr::Resolve (type.get_size_expr (), false);
+  auto capacity_type = TypeCheckExpr::Resolve (type.get_size_expr ());
   if (capacity_type->get_kind () == TyTy::TypeKind::ERROR)
     return;
 
diff --git a/gcc/rust/typecheck/rust-hir-type-check.cc b/gcc/rust/typecheck/rust-hir-type-check.cc
index 60531c0..1d26d60 100644
--- a/gcc/rust/typecheck/rust-hir-type-check.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check.cc
@@ -90,7 +90,7 @@ TypeCheckExpr::visit (HIR::BlockExpr &expr)
       if (!s->is_item ())
 	continue;
 
-      TypeCheckStmt::Resolve (s.get (), inside_loop);
+      TypeCheckStmt::Resolve (s.get ());
     }
 
   for (auto &s : expr.get_statements ())
@@ -98,7 +98,7 @@ TypeCheckExpr::visit (HIR::BlockExpr &expr)
       if (s->is_item ())
 	continue;
 
-      auto resolved = TypeCheckStmt::Resolve (s.get (), inside_loop);
+      auto resolved = TypeCheckStmt::Resolve (s.get ());
       if (resolved == nullptr)
 	{
 	  rust_error_at (s->get_locus (), "failure to resolve type");
@@ -114,9 +114,7 @@ TypeCheckExpr::visit (HIR::BlockExpr &expr)
     }
 
   if (expr.has_expr ())
-    infered
-      = TypeCheckExpr::Resolve (expr.get_final_expr ().get (), inside_loop)
-	  ->clone ();
+    infered = TypeCheckExpr::Resolve (expr.get_final_expr ().get ())->clone ();
   else if (expr.is_tail_reachable ())
     infered
       = TyTy::TupleType::get_unit_type (expr.get_mappings ().get_hirid ());
@@ -184,7 +182,7 @@ TraitItemReference::get_type_from_constant (
   if (constant.has_expr ())
     {
       TyTy::BaseType *expr
-	= TypeCheckExpr::Resolve (constant.get_expr ().get (), false);
+	= TypeCheckExpr::Resolve (constant.get_expr ().get ());
 
       return type->unify (expr);
     }
diff --git a/gcc/rust/typecheck/rust-hir-type-check.h b/gcc/rust/typecheck/rust-hir-type-check.h
index 8e33783..07c7a5c 100644
--- a/gcc/rust/typecheck/rust-hir-type-check.h
+++ b/gcc/rust/typecheck/rust-hir-type-check.h
@@ -126,6 +126,8 @@ public:
       }
   }
 
+  bool have_loop_context () const { return !loop_type_stack.empty (); }
+
   void push_new_loop_context (HirId id, Location locus)
   {
     TyTy::BaseType *infer_var
diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc
index f03bc82..84aa835 100644
--- a/gcc/rust/typecheck/rust-tyty.cc
+++ b/gcc/rust/typecheck/rust-tyty.cc
@@ -3227,7 +3227,7 @@ TypeCheckCallExpr::visit (ADTType &type)
       StructFieldType *field = variant.get_field_at_index (i);
       BaseType *field_tyty = field->get_field_type ();
 
-      BaseType *arg = Resolver::TypeCheckExpr::Resolve (argument.get (), false);
+      BaseType *arg = Resolver::TypeCheckExpr::Resolve (argument.get ());
       if (arg->get_kind () == TyTy::TypeKind::ERROR)
 	{
 	  rust_error_at (argument->get_locus (),
@@ -3285,7 +3285,7 @@ TypeCheckCallExpr::visit (FnType &type)
   for (auto &argument : call.get_arguments ())
     {
       auto argument_expr_tyty
-	= Resolver::TypeCheckExpr::Resolve (argument.get (), false);
+	= Resolver::TypeCheckExpr::Resolve (argument.get ());
       if (argument_expr_tyty->get_kind () == TyTy::TypeKind::ERROR)
 	{
 	  rust_error_at (
@@ -3341,7 +3341,7 @@ TypeCheckCallExpr::visit (FnPtr &type)
     {
       auto fnparam = type.param_at (i);
       auto argument_expr_tyty
-	= Resolver::TypeCheckExpr::Resolve (argument.get (), false);
+	= Resolver::TypeCheckExpr::Resolve (argument.get ());
       if (argument_expr_tyty->get_kind () == TyTy::TypeKind::ERROR)
 	{
 	  rust_error_at (
@@ -3396,7 +3396,7 @@ TypeCheckMethodCallExpr::visit (FnType &type)
     {
       auto fnparam = type.param_at (i);
       auto argument_expr_tyty
-	= Resolver::TypeCheckExpr::Resolve (argument.get (), false);
+	= Resolver::TypeCheckExpr::Resolve (argument.get ());
       if (argument_expr_tyty->get_kind () == TyTy::TypeKind::ERROR)
 	{
 	  rust_error_at (