Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/hir-ty/src/infer/closure.rs')
| -rw-r--r-- | crates/hir-ty/src/infer/closure.rs | 78 |
1 files changed, 33 insertions, 45 deletions
diff --git a/crates/hir-ty/src/infer/closure.rs b/crates/hir-ty/src/infer/closure.rs index 4a57b2f375..2637ed6b3e 100644 --- a/crates/hir-ty/src/infer/closure.rs +++ b/crates/hir-ty/src/infer/closure.rs @@ -2,8 +2,7 @@ pub(crate) mod analysis; -use std::ops::ControlFlow; -use std::{iter, mem}; +use std::{iter, mem, ops::ControlFlow}; use hir_def::{ TraitId, @@ -18,7 +17,6 @@ use rustc_type_ir::{ }; use tracing::debug; -use crate::traits::FnTrait; use crate::{ FnAbi, db::{InternedClosure, InternedCoroutine}, @@ -31,25 +29,25 @@ use crate::{ BoundRegionConversionTime, DefineOpaqueTypes, InferOk, InferResult, traits::{ObligationCause, PredicateObligations}, }, - mapping::{ChalkToNextSolver, NextSolverToChalk}, util::explicit_item_bounds, }, + traits::FnTrait, }; use super::{Expectation, InferenceContext}; #[derive(Debug)] -struct ClosureSignatures<'tcx> { +struct ClosureSignatures<'db> { /// The signature users of the closure see. - bound_sig: PolyFnSig<'tcx>, + bound_sig: PolyFnSig<'db>, /// The signature within the function body. /// This mostly differs in the sense that lifetimes are now early bound and any /// opaque types from the signature expectation are overridden in case there are /// explicit hidden types written by the user in the closure signature. - liberated_sig: FnSig<'tcx>, + liberated_sig: FnSig<'db>, } -impl<'db> InferenceContext<'db> { +impl<'db> InferenceContext<'_, 'db> { pub(super) fn infer_closure( &mut self, body: ExprId, @@ -58,15 +56,13 @@ impl<'db> InferenceContext<'db> { arg_types: &[Option<TypeRefId>], closure_kind: ClosureKind, tgt_expr: ExprId, - expected: &Expectation, - ) -> crate::Ty { + expected: &Expectation<'db>, + ) -> Ty<'db> { assert_eq!(args.len(), arg_types.len()); - let interner = self.table.interner; + let interner = self.interner(); let (expected_sig, expected_kind) = match expected.to_option(&mut self.table) { - Some(expected_ty) => { - self.deduce_closure_signature(expected_ty.to_nextsolver(interner), closure_kind) - } + Some(expected_ty) => self.deduce_closure_signature(expected_ty, closure_kind), None => (None, None), }; @@ -79,10 +75,7 @@ impl<'db> InferenceContext<'db> { let (id, ty, resume_yield_tys) = match closure_kind { ClosureKind::Coroutine(_) => { let yield_ty = self.table.next_ty_var(); - let resume_ty = liberated_sig - .inputs() - .get(0) - .unwrap_or(self.result.standard_types.unit.to_nextsolver(interner)); + let resume_ty = liberated_sig.inputs().get(0).unwrap_or(self.types.unit); // FIXME: Infer the upvars later. let parts = CoroutineArgsParts { @@ -102,11 +95,7 @@ impl<'db> InferenceContext<'db> { CoroutineArgs::new(interner, parts).args, ); - ( - None, - coroutine_ty, - Some((resume_ty.to_chalk(interner), yield_ty.to_chalk(interner))), - ) + (None, coroutine_ty, Some((resume_ty, yield_ty))) } // FIXME(next-solver): `ClosureKind::Async` should really be a separate arm that creates a `CoroutineClosure`. // But for now we treat it as a closure. @@ -115,7 +104,7 @@ impl<'db> InferenceContext<'db> { match expected_kind { Some(kind) => { self.result.closure_info.insert( - closure_id.into(), + closure_id, ( Vec::new(), match kind { @@ -151,13 +140,13 @@ impl<'db> InferenceContext<'db> { // Now go through the argument patterns for (arg_pat, arg_ty) in args.iter().zip(bound_sig.skip_binder().inputs()) { - self.infer_top_pat(*arg_pat, &arg_ty.to_chalk(interner), None); + self.infer_top_pat(*arg_pat, arg_ty, None); } // FIXME: lift these out into a struct let prev_diverges = mem::replace(&mut self.diverges, Diverges::Maybe); let prev_closure = mem::replace(&mut self.current_closure, id); - let prev_ret_ty = mem::replace(&mut self.return_ty, body_ret_ty.to_chalk(interner)); + let prev_ret_ty = mem::replace(&mut self.return_ty, body_ret_ty); let prev_ret_coercion = self.return_coercion.replace(CoerceMany::new(body_ret_ty)); let prev_resume_yield_tys = mem::replace(&mut self.resume_yield_tys, resume_yield_tys); @@ -171,7 +160,7 @@ impl<'db> InferenceContext<'db> { self.current_closure = prev_closure; self.resume_yield_tys = prev_resume_yield_tys; - ty.to_chalk(interner) + ty } fn fn_trait_kind_from_def_id(&self, trait_id: TraitId) -> Option<rustc_type_ir::ClosureKind> { @@ -209,14 +198,13 @@ impl<'db> InferenceContext<'db> { .deduce_closure_signature_from_predicates( expected_ty, closure_kind, - explicit_item_bounds(self.table.interner, def_id) - .iter_instantiated(self.table.interner, args) + explicit_item_bounds(self.interner(), def_id) + .iter_instantiated(self.interner(), args) .map(|clause| clause.as_predicate()), ), TyKind::Dynamic(object_type, ..) => { let sig = object_type.projection_bounds().into_iter().find_map(|pb| { - let pb = - pb.with_self_ty(self.table.interner, Ty::new_unit(self.table.interner)); + let pb = pb.with_self_ty(self.interner(), Ty::new_unit(self.interner())); self.deduce_sig_from_projection(closure_kind, pb) }); let kind = object_type @@ -226,7 +214,7 @@ impl<'db> InferenceContext<'db> { } TyKind::Infer(rustc_type_ir::TyVar(vid)) => self .deduce_closure_signature_from_predicates( - Ty::new_var(self.table.interner, self.table.infer_ctxt.root_var(vid)), + Ty::new_var(self.interner(), self.table.infer_ctxt.root_var(vid)), closure_kind, self.table.obligations_for_self_ty(vid).into_iter().map(|obl| obl.predicate), ), @@ -251,7 +239,7 @@ impl<'db> InferenceContext<'db> { let mut expected_kind = None; for pred in rustc_type_ir::elaborate::elaborate( - self.table.interner, + self.interner(), // Reverse the obligations here, since `elaborate_*` uses a stack, // and we want to keep inference generally in the same order of // the registered obligations. @@ -313,7 +301,7 @@ impl<'db> InferenceContext<'db> { // even though the normalized form may not name `expected_ty`. However, this matches the existing // behaviour of the old solver and would be technically a breaking change to fix. let generalized_fnptr_sig = self.table.next_ty_var(); - let inferred_fnptr_sig = Ty::new_fn_ptr(self.table.interner, inferred_sig); + let inferred_fnptr_sig = Ty::new_fn_ptr(self.interner(), inferred_sig); // FIXME: Report diagnostics. _ = self .table @@ -326,7 +314,7 @@ impl<'db> InferenceContext<'db> { self.table.infer_ctxt.resolve_vars_if_possible(generalized_fnptr_sig); if resolved_sig.visit_with(&mut MentionsTy { expected_ty }).is_continue() { - expected_sig = Some(resolved_sig.fn_sig(self.table.interner)); + expected_sig = Some(resolved_sig.fn_sig(self.interner())); } } else if inferred_sig.visit_with(&mut MentionsTy { expected_ty }).is_continue() { expected_sig = inferred_sig; @@ -339,7 +327,7 @@ impl<'db> InferenceContext<'db> { // many viable options, so pick the most restrictive. let trait_def_id = match bound_predicate.skip_binder() { PredicateKind::Clause(ClauseKind::Projection(data)) => { - Some(data.projection_term.trait_def_id(self.table.interner).0) + Some(data.projection_term.trait_def_id(self.interner()).0) } PredicateKind::Clause(ClauseKind::Trait(data)) => Some(data.def_id().0), _ => None, @@ -427,7 +415,7 @@ impl<'db> InferenceContext<'db> { let ret_param_ty = projection.skip_binder().term.expect_type(); debug!(?ret_param_ty); - let sig = projection.rebind(self.table.interner.mk_fn_sig( + let sig = projection.rebind(self.interner().mk_fn_sig( input_tys, ret_param_ty, false, @@ -515,7 +503,7 @@ impl<'db> InferenceContext<'db> { // that does not misuse a `FnSig` type, but that can be done separately. let return_ty = return_ty.unwrap_or_else(|| self.table.next_ty_var()); - let sig = projection.rebind(self.table.interner.mk_fn_sig( + let sig = projection.rebind(self.interner().mk_fn_sig( input_tys, return_ty, false, @@ -619,7 +607,7 @@ impl<'db> InferenceContext<'db> { // in this binder we are creating. assert!(!expected_sig.skip_binder().has_vars_bound_above(rustc_type_ir::INNERMOST)); let bound_sig = expected_sig.map_bound(|sig| { - self.table.interner.mk_fn_sig( + self.interner().mk_fn_sig( sig.inputs(), sig.output(), sig.c_variadic, @@ -631,7 +619,7 @@ impl<'db> InferenceContext<'db> { // `deduce_expectations_from_expected_type` introduces // late-bound lifetimes defined elsewhere, which we now // anonymize away, so as not to confuse the user. - let bound_sig = self.table.interner.anonymize_bound_vars(bound_sig); + let bound_sig = self.interner().anonymize_bound_vars(bound_sig); let closure_sigs = self.closure_sigs(bound_sig); @@ -723,7 +711,7 @@ impl<'db> InferenceContext<'db> { .into_iter() .map(|ty| table.infer_ctxt.resolve_vars_if_possible(ty)); - expected_sigs.liberated_sig = table.interner.mk_fn_sig( + expected_sigs.liberated_sig = table.interner().mk_fn_sig( inputs, supplied_output_ty, expected_sigs.liberated_sig.c_variadic, @@ -744,12 +732,12 @@ impl<'db> InferenceContext<'db> { decl_inputs: &[Option<TypeRefId>], decl_output: Option<TypeRefId>, ) -> PolyFnSig<'db> { - let interner = self.table.interner; + let interner = self.interner(); let supplied_return = match decl_output { Some(output) => { let output = self.make_body_ty(output); - self.process_user_written_ty(output).to_nextsolver(interner) + self.process_user_written_ty(output) } None => self.table.next_ty_var(), }; @@ -757,7 +745,7 @@ impl<'db> InferenceContext<'db> { let supplied_arguments = decl_inputs.iter().map(|&input| match input { Some(input) => { let input = self.make_body_ty(input); - self.process_user_written_ty(input).to_nextsolver(interner) + self.process_user_written_ty(input) } None => self.table.next_ty_var(), }); @@ -779,7 +767,7 @@ impl<'db> InferenceContext<'db> { decl_inputs: &[Option<TypeRefId>], decl_output: Option<TypeRefId>, ) -> PolyFnSig<'db> { - let interner = self.table.interner; + let interner = self.interner(); let err_ty = Ty::new_error(interner, ErrorGuaranteed); if let Some(output) = decl_output { |