From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1643) id 7CD24388B595; Wed, 8 Jun 2022 12:50:09 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 7CD24388B595 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Thomas Schwinge To: gcc-cvs@gcc.gnu.org Subject: [gcc/devel/rust/master] Remove inside_loop parameter from type resolution of stmts and expressions X-Act-Checkin: gcc X-Git-Author: Philip Herron X-Git-Refname: refs/heads/devel/rust/master X-Git-Oldrev: 79d977e759b073a0a4d422b9a1032427ddc05295 X-Git-Newrev: 7f7efa4463d95e23f375583b02db6408b6610a2f Message-Id: <20220608125009.7CD24388B595@sourceware.org> Date: Wed, 8 Jun 2022 12:50:09 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 08 Jun 2022 12:50:09 -0000 https://gcc.gnu.org/g:7f7efa4463d95e23f375583b02db6408b6610a2f commit 7f7efa4463d95e23f375583b02db6408b6610a2f Author: Philip Herron Date: Tue May 24 17:03:49 2022 +0100 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. Diff: --- gcc/rust/typecheck/rust-hir-trait-resolve.cc | 3 +- gcc/rust/typecheck/rust-hir-type-check-enumitem.h | 2 +- gcc/rust/typecheck/rust-hir-type-check-expr.cc | 20 ++-- gcc/rust/typecheck/rust-hir-type-check-expr.h | 112 ++++++++++------------ gcc/rust/typecheck/rust-hir-type-check-implitem.h | 5 +- gcc/rust/typecheck/rust-hir-type-check-item.h | 2 +- gcc/rust/typecheck/rust-hir-type-check-pattern.cc | 14 +-- gcc/rust/typecheck/rust-hir-type-check-stmt.h | 21 ++-- gcc/rust/typecheck/rust-hir-type-check-struct.cc | 11 +-- gcc/rust/typecheck/rust-hir-type-check-toplevel.h | 5 +- gcc/rust/typecheck/rust-hir-type-check-type.cc | 2 +- gcc/rust/typecheck/rust-hir-type-check.cc | 10 +- gcc/rust/typecheck/rust-hir-type-check.h | 2 + gcc/rust/typecheck/rust-tyty.cc | 8 +- 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 13edd8d1a6f..7e87e1d0a44 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 d6baff11056..16cae9c38b2 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 394eee07b5e..d96a85cc342 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 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 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 411d45de41f..d7c3da928c1 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 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 (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 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 % 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 % 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 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 db055053e63..c7af9b23ef9 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 71b6b815e36..85733357fbd 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 bceafde38a7..be3b8e4c011 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 ( 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 ( 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 ( 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 ( 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 b0ffd2a2157..327bffa6971 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 a1cd35977ab..6634ad4ad7d 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 eaa8d59d001..fe961d14fa9 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 bd40344aa6c..85de3a1d07d 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 60531c0933d..1d26d60ccba 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 8e337839095..07c7a5cf60b 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 f03bc8234c8..84aa8354536 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 (