rustc_hir_typeck/closure.rs
1//! Code for type-checking closure expressions.
2
3use std::iter;
4use std::ops::ControlFlow;
5
6use rustc_abi::ExternAbi;
7use rustc_errors::ErrorGuaranteed;
8use rustc_hir as hir;
9use rustc_hir::lang_items::LangItem;
10use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
11use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferOk, InferResult};
12use rustc_infer::traits::{ObligationCauseCode, PredicateObligations};
13use rustc_macros::{TypeFoldable, TypeVisitable};
14use rustc_middle::span_bug;
15use rustc_middle::ty::{
16 self, ClosureKind, GenericArgs, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
17 TypeVisitableExt, TypeVisitor,
18};
19use rustc_span::def_id::LocalDefId;
20use rustc_span::{DUMMY_SP, Span};
21use rustc_trait_selection::error_reporting::traits::ArgKind;
22use rustc_trait_selection::traits;
23use tracing::{debug, instrument, trace};
24
25use super::{CoroutineTypes, Expectation, FnCtxt, check_fn};
26
27/// What signature do we *expect* the closure to have from context?
28#[derive(Debug, Clone, TypeFoldable, TypeVisitable)]
29struct ExpectedSig<'tcx> {
30 /// Span that gave us this expectation, if we know that.
31 cause_span: Option<Span>,
32 sig: ty::PolyFnSig<'tcx>,
33}
34
35#[derive(Debug)]
36struct ClosureSignatures<'tcx> {
37 /// The signature users of the closure see.
38 bound_sig: ty::PolyFnSig<'tcx>,
39 /// The signature within the function body.
40 /// This mostly differs in the sense that lifetimes are now early bound and any
41 /// opaque types from the signature expectation are overridden in case there are
42 /// explicit hidden types written by the user in the closure signature.
43 liberated_sig: ty::FnSig<'tcx>,
44}
45
46impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
47 #[instrument(skip(self, closure), level = "debug")]
48 pub(crate) fn check_expr_closure(
49 &self,
50 closure: &hir::Closure<'tcx>,
51 expr_span: Span,
52 expected: Expectation<'tcx>,
53 ) -> Ty<'tcx> {
54 let tcx = self.tcx;
55 let body = tcx.hir_body(closure.body);
56 let expr_def_id = closure.def_id;
57
58 // It's always helpful for inference if we know the kind of
59 // closure sooner rather than later, so first examine the expected
60 // type, and see if can glean a closure kind from there.
61 let (expected_sig, expected_kind) = match expected.to_option(self) {
62 Some(ty) => self.deduce_closure_signature(
63 self.try_structurally_resolve_type(expr_span, ty),
64 closure.kind,
65 ),
66 None => (None, None),
67 };
68
69 let ClosureSignatures { bound_sig, mut liberated_sig } =
70 self.sig_of_closure(expr_def_id, closure.fn_decl, closure.kind, expected_sig);
71
72 debug!(?bound_sig, ?liberated_sig);
73
74 let parent_args =
75 GenericArgs::identity_for_item(tcx, tcx.typeck_root_def_id(expr_def_id.to_def_id()));
76
77 let tupled_upvars_ty = self.next_ty_var(expr_span);
78
79 // FIXME: We could probably actually just unify this further --
80 // instead of having a `FnSig` and a `Option<CoroutineTypes>`,
81 // we can have a `ClosureSignature { Coroutine { .. }, Closure { .. } }`,
82 // similar to how `ty::GenSig` is a distinct data structure.
83 let (closure_ty, coroutine_types) = match closure.kind {
84 hir::ClosureKind::Closure => {
85 // Tuple up the arguments and insert the resulting function type into
86 // the `closures` table.
87 let sig = bound_sig.map_bound(|sig| {
88 tcx.mk_fn_sig(
89 [Ty::new_tup(tcx, sig.inputs())],
90 sig.output(),
91 sig.c_variadic,
92 sig.safety,
93 sig.abi,
94 )
95 });
96
97 debug!(?sig, ?expected_kind);
98
99 let closure_kind_ty = match expected_kind {
100 Some(kind) => Ty::from_closure_kind(tcx, kind),
101
102 // Create a type variable (for now) to represent the closure kind.
103 // It will be unified during the upvar inference phase (`upvar.rs`)
104 None => self.next_ty_var(expr_span),
105 };
106
107 let closure_args = ty::ClosureArgs::new(
108 tcx,
109 ty::ClosureArgsParts {
110 parent_args,
111 closure_kind_ty,
112 closure_sig_as_fn_ptr_ty: Ty::new_fn_ptr(tcx, sig),
113 tupled_upvars_ty,
114 },
115 );
116
117 (Ty::new_closure(tcx, expr_def_id.to_def_id(), closure_args.args), None)
118 }
119 hir::ClosureKind::Coroutine(kind) => {
120 let yield_ty = match kind {
121 hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Gen, _)
122 | hir::CoroutineKind::Coroutine(_) => {
123 let yield_ty = self.next_ty_var(expr_span);
124 self.require_type_is_sized(
125 yield_ty,
126 expr_span,
127 ObligationCauseCode::SizedYieldType,
128 );
129 yield_ty
130 }
131 // HACK(-Ztrait-solver=next): In the *old* trait solver, we must eagerly
132 // guide inference on the yield type so that we can handle `AsyncIterator`
133 // in this block in projection correctly. In the new trait solver, it is
134 // not a problem.
135 hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::AsyncGen, _) => {
136 let yield_ty = self.next_ty_var(expr_span);
137 self.require_type_is_sized(
138 yield_ty,
139 expr_span,
140 ObligationCauseCode::SizedYieldType,
141 );
142
143 Ty::new_adt(
144 tcx,
145 tcx.adt_def(tcx.require_lang_item(hir::LangItem::Poll, expr_span)),
146 tcx.mk_args(&[Ty::new_adt(
147 tcx,
148 tcx.adt_def(
149 tcx.require_lang_item(hir::LangItem::Option, expr_span),
150 ),
151 tcx.mk_args(&[yield_ty.into()]),
152 )
153 .into()]),
154 )
155 }
156 hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Async, _) => {
157 tcx.types.unit
158 }
159 };
160
161 // Resume type defaults to `()` if the coroutine has no argument.
162 let resume_ty = liberated_sig.inputs().get(0).copied().unwrap_or(tcx.types.unit);
163
164 // Coroutines that come from coroutine closures have not yet determined
165 // their kind ty, so make a fresh infer var which will be constrained
166 // later during upvar analysis. Regular coroutines always have the kind
167 // ty of `().`
168 let kind_ty = match kind {
169 hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure) => {
170 self.next_ty_var(expr_span)
171 }
172 _ => tcx.types.unit,
173 };
174
175 let coroutine_args = ty::CoroutineArgs::new(
176 tcx,
177 ty::CoroutineArgsParts {
178 parent_args,
179 kind_ty,
180 resume_ty,
181 yield_ty,
182 return_ty: liberated_sig.output(),
183 tupled_upvars_ty,
184 },
185 );
186
187 (
188 Ty::new_coroutine(tcx, expr_def_id.to_def_id(), coroutine_args.args),
189 Some(CoroutineTypes { resume_ty, yield_ty }),
190 )
191 }
192 hir::ClosureKind::CoroutineClosure(kind) => {
193 let (bound_return_ty, bound_yield_ty) = match kind {
194 hir::CoroutineDesugaring::Gen => {
195 // `iter!` closures always return unit and yield the `Iterator::Item` type
196 // that we have to infer.
197 (tcx.types.unit, self.infcx.next_ty_var(expr_span))
198 }
199 hir::CoroutineDesugaring::Async => {
200 // async closures always return the type ascribed after the `->` (if present),
201 // and yield `()`.
202 (bound_sig.skip_binder().output(), tcx.types.unit)
203 }
204 hir::CoroutineDesugaring::AsyncGen => {
205 todo!("`async gen` closures not supported yet")
206 }
207 };
208 // Compute all of the variables that will be used to populate the coroutine.
209 let resume_ty = self.next_ty_var(expr_span);
210
211 let closure_kind_ty = match expected_kind {
212 Some(kind) => Ty::from_closure_kind(tcx, kind),
213
214 // Create a type variable (for now) to represent the closure kind.
215 // It will be unified during the upvar inference phase (`upvar.rs`)
216 None => self.next_ty_var(expr_span),
217 };
218
219 let coroutine_captures_by_ref_ty = self.next_ty_var(expr_span);
220 let closure_args = ty::CoroutineClosureArgs::new(
221 tcx,
222 ty::CoroutineClosureArgsParts {
223 parent_args,
224 closure_kind_ty,
225 signature_parts_ty: Ty::new_fn_ptr(
226 tcx,
227 bound_sig.map_bound(|sig| {
228 tcx.mk_fn_sig(
229 [
230 resume_ty,
231 Ty::new_tup_from_iter(tcx, sig.inputs().iter().copied()),
232 ],
233 Ty::new_tup(tcx, &[bound_yield_ty, bound_return_ty]),
234 sig.c_variadic,
235 sig.safety,
236 sig.abi,
237 )
238 }),
239 ),
240 tupled_upvars_ty,
241 coroutine_captures_by_ref_ty,
242 },
243 );
244
245 let coroutine_kind_ty = match expected_kind {
246 Some(kind) => Ty::from_coroutine_closure_kind(tcx, kind),
247
248 // Create a type variable (for now) to represent the closure kind.
249 // It will be unified during the upvar inference phase (`upvar.rs`)
250 None => self.next_ty_var(expr_span),
251 };
252
253 let coroutine_upvars_ty = self.next_ty_var(expr_span);
254
255 // We need to turn the liberated signature that we got from HIR, which
256 // looks something like `|Args...| -> T`, into a signature that is suitable
257 // for type checking the inner body of the closure, which always returns a
258 // coroutine. To do so, we use the `CoroutineClosureSignature` to compute
259 // the coroutine type, filling in the tupled_upvars_ty and kind_ty with infer
260 // vars which will get constrained during upvar analysis.
261 let coroutine_output_ty = tcx.liberate_late_bound_regions(
262 expr_def_id.to_def_id(),
263 closure_args.coroutine_closure_sig().map_bound(|sig| {
264 sig.to_coroutine(
265 tcx,
266 parent_args,
267 coroutine_kind_ty,
268 tcx.coroutine_for_closure(expr_def_id),
269 coroutine_upvars_ty,
270 )
271 }),
272 );
273 liberated_sig = tcx.mk_fn_sig(
274 liberated_sig.inputs().iter().copied(),
275 coroutine_output_ty,
276 liberated_sig.c_variadic,
277 liberated_sig.safety,
278 liberated_sig.abi,
279 );
280
281 (Ty::new_coroutine_closure(tcx, expr_def_id.to_def_id(), closure_args.args), None)
282 }
283 };
284
285 check_fn(
286 &mut FnCtxt::new(self, self.param_env, closure.def_id),
287 liberated_sig,
288 coroutine_types,
289 closure.fn_decl,
290 expr_def_id,
291 body,
292 // Closure "rust-call" ABI doesn't support unsized params
293 false,
294 );
295
296 closure_ty
297 }
298
299 /// Given the expected type, figures out what it can about this closure we
300 /// are about to type check:
301 #[instrument(skip(self), level = "debug", ret)]
302 fn deduce_closure_signature(
303 &self,
304 expected_ty: Ty<'tcx>,
305 closure_kind: hir::ClosureKind,
306 ) -> (Option<ExpectedSig<'tcx>>, Option<ty::ClosureKind>) {
307 match *expected_ty.kind() {
308 ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => self
309 .deduce_closure_signature_from_predicates(
310 expected_ty,
311 closure_kind,
312 self.tcx
313 .explicit_item_self_bounds(def_id)
314 .iter_instantiated_copied(self.tcx, args)
315 .map(|(c, s)| (c.as_predicate(), s)),
316 ),
317 ty::Dynamic(object_type, ..) => {
318 let sig = object_type.projection_bounds().find_map(|pb| {
319 let pb = pb.with_self_ty(self.tcx, self.tcx.types.trait_object_dummy_self);
320 self.deduce_sig_from_projection(None, closure_kind, pb)
321 });
322 let kind = object_type
323 .principal_def_id()
324 .and_then(|did| self.tcx.fn_trait_kind_from_def_id(did));
325 (sig, kind)
326 }
327 ty::Infer(ty::TyVar(vid)) => self.deduce_closure_signature_from_predicates(
328 Ty::new_var(self.tcx, self.root_var(vid)),
329 closure_kind,
330 self.obligations_for_self_ty(vid)
331 .into_iter()
332 .map(|obl| (obl.predicate, obl.cause.span)),
333 ),
334 ty::FnPtr(sig_tys, hdr) => match closure_kind {
335 hir::ClosureKind::Closure => {
336 let expected_sig = ExpectedSig { cause_span: None, sig: sig_tys.with(hdr) };
337 (Some(expected_sig), Some(ty::ClosureKind::Fn))
338 }
339 hir::ClosureKind::Coroutine(_) | hir::ClosureKind::CoroutineClosure(_) => {
340 (None, None)
341 }
342 },
343 _ => (None, None),
344 }
345 }
346
347 fn deduce_closure_signature_from_predicates(
348 &self,
349 expected_ty: Ty<'tcx>,
350 closure_kind: hir::ClosureKind,
351 predicates: impl DoubleEndedIterator<Item = (ty::Predicate<'tcx>, Span)>,
352 ) -> (Option<ExpectedSig<'tcx>>, Option<ty::ClosureKind>) {
353 let mut expected_sig = None;
354 let mut expected_kind = None;
355
356 for (pred, span) in traits::elaborate(
357 self.tcx,
358 // Reverse the obligations here, since `elaborate_*` uses a stack,
359 // and we want to keep inference generally in the same order of
360 // the registered obligations.
361 predicates.rev(),
362 )
363 // We only care about self bounds
364 .filter_only_self()
365 {
366 debug!(?pred);
367 let bound_predicate = pred.kind();
368
369 // Given a Projection predicate, we can potentially infer
370 // the complete signature.
371 if expected_sig.is_none()
372 && let ty::PredicateKind::Clause(ty::ClauseKind::Projection(proj_predicate)) =
373 bound_predicate.skip_binder()
374 {
375 let inferred_sig = self.normalize(
376 span,
377 self.deduce_sig_from_projection(
378 Some(span),
379 closure_kind,
380 bound_predicate.rebind(proj_predicate),
381 ),
382 );
383
384 // Make sure that we didn't infer a signature that mentions itself.
385 // This can happen when we elaborate certain supertrait bounds that
386 // mention projections containing the `Self` type. See #105401.
387 struct MentionsTy<'tcx> {
388 expected_ty: Ty<'tcx>,
389 }
390 impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MentionsTy<'tcx> {
391 type Result = ControlFlow<()>;
392
393 fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
394 if t == self.expected_ty {
395 ControlFlow::Break(())
396 } else {
397 t.super_visit_with(self)
398 }
399 }
400 }
401
402 // Don't infer a closure signature from a goal that names the closure type as this will
403 // (almost always) lead to occurs check errors later in type checking.
404 if self.next_trait_solver()
405 && let Some(inferred_sig) = inferred_sig
406 {
407 // In the new solver it is difficult to explicitly normalize the inferred signature as we
408 // would have to manually handle universes and rewriting bound vars and placeholders back
409 // and forth.
410 //
411 // Instead we take advantage of the fact that we relating an inference variable with an alias
412 // will only instantiate the variable if the alias is rigid(*not quite). Concretely we:
413 // - Create some new variable `?sig`
414 // - Equate `?sig` with the unnormalized signature, e.g. `fn(<Foo<?x> as Trait>::Assoc)`
415 // - Depending on whether `<Foo<?x> as Trait>::Assoc` is rigid, ambiguous or normalizeable,
416 // we will either wind up with `?sig=<Foo<?x> as Trait>::Assoc/?y/ConcreteTy` respectively.
417 //
418 // *: In cases where there are ambiguous aliases in the signature that make use of bound vars
419 // they will wind up present in `?sig` even though they are non-rigid.
420 //
421 // This is a bit weird and means we may wind up discarding the goal due to it naming `expected_ty`
422 // even though the normalized form may not name `expected_ty`. However, this matches the existing
423 // behaviour of the old solver and would be technically a breaking change to fix.
424 let generalized_fnptr_sig = self.next_ty_var(span);
425 let inferred_fnptr_sig = Ty::new_fn_ptr(self.tcx, inferred_sig.sig);
426 self.demand_eqtype(span, inferred_fnptr_sig, generalized_fnptr_sig);
427
428 let resolved_sig = self.resolve_vars_if_possible(generalized_fnptr_sig);
429
430 if resolved_sig.visit_with(&mut MentionsTy { expected_ty }).is_continue() {
431 expected_sig = Some(ExpectedSig {
432 cause_span: inferred_sig.cause_span,
433 sig: resolved_sig.fn_sig(self.tcx),
434 });
435 }
436 } else {
437 if inferred_sig.visit_with(&mut MentionsTy { expected_ty }).is_continue() {
438 expected_sig = inferred_sig;
439 }
440 }
441 }
442
443 // Even if we can't infer the full signature, we may be able to
444 // infer the kind. This can occur when we elaborate a predicate
445 // like `F : Fn<A>`. Note that due to subtyping we could encounter
446 // many viable options, so pick the most restrictive.
447 let trait_def_id = match bound_predicate.skip_binder() {
448 ty::PredicateKind::Clause(ty::ClauseKind::Projection(data)) => {
449 Some(data.projection_term.trait_def_id(self.tcx))
450 }
451 ty::PredicateKind::Clause(ty::ClauseKind::Trait(data)) => Some(data.def_id()),
452 _ => None,
453 };
454
455 if let Some(trait_def_id) = trait_def_id {
456 let found_kind = match closure_kind {
457 hir::ClosureKind::Closure
458 // FIXME(iter_macro): Someday we'll probably want iterator closures instead of
459 // just using Fn* for iterators.
460 | hir::ClosureKind::CoroutineClosure(hir::CoroutineDesugaring::Gen) => {
461 self.tcx.fn_trait_kind_from_def_id(trait_def_id)
462 }
463 hir::ClosureKind::CoroutineClosure(hir::CoroutineDesugaring::Async) => self
464 .tcx
465 .async_fn_trait_kind_from_def_id(trait_def_id)
466 .or_else(|| self.tcx.fn_trait_kind_from_def_id(trait_def_id)),
467 _ => None,
468 };
469
470 if let Some(found_kind) = found_kind {
471 // always use the closure kind that is more permissive.
472 match (expected_kind, found_kind) {
473 (None, _) => expected_kind = Some(found_kind),
474 (Some(ClosureKind::FnMut), ClosureKind::Fn) => {
475 expected_kind = Some(ClosureKind::Fn)
476 }
477 (Some(ClosureKind::FnOnce), ClosureKind::Fn | ClosureKind::FnMut) => {
478 expected_kind = Some(found_kind)
479 }
480 _ => {}
481 }
482 }
483 }
484 }
485
486 (expected_sig, expected_kind)
487 }
488
489 /// Given a projection like "<F as Fn(X)>::Result == Y", we can deduce
490 /// everything we need to know about a closure or coroutine.
491 ///
492 /// The `cause_span` should be the span that caused us to
493 /// have this expected signature, or `None` if we can't readily
494 /// know that.
495 #[instrument(level = "debug", skip(self, cause_span), ret)]
496 fn deduce_sig_from_projection(
497 &self,
498 cause_span: Option<Span>,
499 closure_kind: hir::ClosureKind,
500 projection: ty::PolyProjectionPredicate<'tcx>,
501 ) -> Option<ExpectedSig<'tcx>> {
502 let def_id = projection.item_def_id();
503
504 // For now, we only do signature deduction based off of the `Fn` and `AsyncFn` traits,
505 // for closures and async closures, respectively.
506 match closure_kind {
507 hir::ClosureKind::Closure if self.tcx.is_lang_item(def_id, LangItem::FnOnceOutput) => {
508 self.extract_sig_from_projection(cause_span, projection)
509 }
510 hir::ClosureKind::CoroutineClosure(hir::CoroutineDesugaring::Async)
511 if self.tcx.is_lang_item(def_id, LangItem::AsyncFnOnceOutput) =>
512 {
513 self.extract_sig_from_projection(cause_span, projection)
514 }
515 // It's possible we've passed the closure to a (somewhat out-of-fashion)
516 // `F: FnOnce() -> Fut, Fut: Future<Output = T>` style bound. Let's still
517 // guide inference here, since it's beneficial for the user.
518 hir::ClosureKind::CoroutineClosure(hir::CoroutineDesugaring::Async)
519 if self.tcx.is_lang_item(def_id, LangItem::FnOnceOutput) =>
520 {
521 self.extract_sig_from_projection_and_future_bound(cause_span, projection)
522 }
523 _ => None,
524 }
525 }
526
527 /// Given an `FnOnce::Output` or `AsyncFn::Output` projection, extract the args
528 /// and return type to infer a [`ty::PolyFnSig`] for the closure.
529 fn extract_sig_from_projection(
530 &self,
531 cause_span: Option<Span>,
532 projection: ty::PolyProjectionPredicate<'tcx>,
533 ) -> Option<ExpectedSig<'tcx>> {
534 let projection = self.resolve_vars_if_possible(projection);
535
536 let arg_param_ty = projection.skip_binder().projection_term.args.type_at(1);
537 debug!(?arg_param_ty);
538
539 let ty::Tuple(input_tys) = *arg_param_ty.kind() else {
540 return None;
541 };
542
543 // Since this is a return parameter type it is safe to unwrap.
544 let ret_param_ty = projection.skip_binder().term.expect_type();
545 debug!(?ret_param_ty);
546
547 let sig = projection.rebind(self.tcx.mk_fn_sig(
548 input_tys,
549 ret_param_ty,
550 false,
551 hir::Safety::Safe,
552 ExternAbi::Rust,
553 ));
554
555 Some(ExpectedSig { cause_span, sig })
556 }
557
558 /// When an async closure is passed to a function that has a "two-part" `Fn`
559 /// and `Future` trait bound, like:
560 ///
561 /// ```rust
562 /// use std::future::Future;
563 ///
564 /// fn not_exactly_an_async_closure<F, Fut>(_f: F)
565 /// where
566 /// F: FnOnce(String, u32) -> Fut,
567 /// Fut: Future<Output = i32>,
568 /// {}
569 /// ```
570 ///
571 /// The we want to be able to extract the signature to guide inference in the async
572 /// closure. We will have two projection predicates registered in this case. First,
573 /// we identify the `FnOnce<Args, Output = ?Fut>` bound, and if the output type is
574 /// an inference variable `?Fut`, we check if that is bounded by a `Future<Output = Ty>`
575 /// projection.
576 ///
577 /// This function is actually best-effort with the return type; if we don't find a
578 /// `Future` projection, we still will return arguments that we extracted from the `FnOnce`
579 /// projection, and the output will be an unconstrained type variable instead.
580 fn extract_sig_from_projection_and_future_bound(
581 &self,
582 cause_span: Option<Span>,
583 projection: ty::PolyProjectionPredicate<'tcx>,
584 ) -> Option<ExpectedSig<'tcx>> {
585 let projection = self.resolve_vars_if_possible(projection);
586
587 let arg_param_ty = projection.skip_binder().projection_term.args.type_at(1);
588 debug!(?arg_param_ty);
589
590 let ty::Tuple(input_tys) = *arg_param_ty.kind() else {
591 return None;
592 };
593
594 // If the return type is a type variable, look for bounds on it.
595 // We could theoretically support other kinds of return types here,
596 // but none of them would be useful, since async closures return
597 // concrete anonymous future types, and their futures are not coerced
598 // into any other type within the body of the async closure.
599 let ty::Infer(ty::TyVar(return_vid)) = *projection.skip_binder().term.expect_type().kind()
600 else {
601 return None;
602 };
603
604 // FIXME: We may want to elaborate here, though I assume this will be exceedingly rare.
605 let mut return_ty = None;
606 for bound in self.obligations_for_self_ty(return_vid) {
607 if let Some(ret_projection) = bound.predicate.as_projection_clause()
608 && let Some(ret_projection) = ret_projection.no_bound_vars()
609 && self.tcx.is_lang_item(ret_projection.def_id(), LangItem::FutureOutput)
610 {
611 return_ty = Some(ret_projection.term.expect_type());
612 break;
613 }
614 }
615
616 // SUBTLE: If we didn't find a `Future<Output = ...>` bound for the return
617 // vid, we still want to attempt to provide inference guidance for the async
618 // closure's arguments. Instantiate a new vid to plug into the output type.
619 //
620 // You may be wondering, what if it's higher-ranked? Well, given that we
621 // found a type variable for the `FnOnce::Output` projection above, we know
622 // that the output can't mention any of the vars.
623 //
624 // Also note that we use a fresh var here for the signature since the signature
625 // records the output of the *future*, and `return_vid` above is the type
626 // variable of the future, not its output.
627 //
628 // FIXME: We probably should store this signature inference output in a way
629 // that does not misuse a `FnSig` type, but that can be done separately.
630 let return_ty =
631 return_ty.unwrap_or_else(|| self.next_ty_var(cause_span.unwrap_or(DUMMY_SP)));
632
633 let sig = projection.rebind(self.tcx.mk_fn_sig(
634 input_tys,
635 return_ty,
636 false,
637 hir::Safety::Safe,
638 ExternAbi::Rust,
639 ));
640
641 Some(ExpectedSig { cause_span, sig })
642 }
643
644 fn sig_of_closure(
645 &self,
646 expr_def_id: LocalDefId,
647 decl: &hir::FnDecl<'tcx>,
648 closure_kind: hir::ClosureKind,
649 expected_sig: Option<ExpectedSig<'tcx>>,
650 ) -> ClosureSignatures<'tcx> {
651 if let Some(e) = expected_sig {
652 self.sig_of_closure_with_expectation(expr_def_id, decl, closure_kind, e)
653 } else {
654 self.sig_of_closure_no_expectation(expr_def_id, decl, closure_kind)
655 }
656 }
657
658 /// If there is no expected signature, then we will convert the
659 /// types that the user gave into a signature.
660 #[instrument(skip(self, expr_def_id, decl), level = "debug")]
661 fn sig_of_closure_no_expectation(
662 &self,
663 expr_def_id: LocalDefId,
664 decl: &hir::FnDecl<'tcx>,
665 closure_kind: hir::ClosureKind,
666 ) -> ClosureSignatures<'tcx> {
667 let bound_sig = self.supplied_sig_of_closure(expr_def_id, decl, closure_kind);
668
669 self.closure_sigs(expr_def_id, bound_sig)
670 }
671
672 /// Invoked to compute the signature of a closure expression. This
673 /// combines any user-provided type annotations (e.g., `|x: u32|
674 /// -> u32 { .. }`) with the expected signature.
675 ///
676 /// The approach is as follows:
677 ///
678 /// - Let `S` be the (higher-ranked) signature that we derive from the user's annotations.
679 /// - Let `E` be the (higher-ranked) signature that we derive from the expectations, if any.
680 /// - If we have no expectation `E`, then the signature of the closure is `S`.
681 /// - Otherwise, the signature of the closure is E. Moreover:
682 /// - Skolemize the late-bound regions in `E`, yielding `E'`.
683 /// - Instantiate all the late-bound regions bound in the closure within `S`
684 /// with fresh (existential) variables, yielding `S'`
685 /// - Require that `E' = S'`
686 /// - We could use some kind of subtyping relationship here,
687 /// I imagine, but equality is easier and works fine for
688 /// our purposes.
689 ///
690 /// The key intuition here is that the user's types must be valid
691 /// from "the inside" of the closure, but the expectation
692 /// ultimately drives the overall signature.
693 ///
694 /// # Examples
695 ///
696 /// ```ignore (illustrative)
697 /// fn with_closure<F>(_: F)
698 /// where F: Fn(&u32) -> &u32 { .. }
699 ///
700 /// with_closure(|x: &u32| { ... })
701 /// ```
702 ///
703 /// Here:
704 /// - E would be `fn(&u32) -> &u32`.
705 /// - S would be `fn(&u32) -> ?T`
706 /// - E' is `&'!0 u32 -> &'!0 u32`
707 /// - S' is `&'?0 u32 -> ?T`
708 ///
709 /// S' can be unified with E' with `['?0 = '!0, ?T = &'!10 u32]`.
710 ///
711 /// # Arguments
712 ///
713 /// - `expr_def_id`: the `LocalDefId` of the closure expression
714 /// - `decl`: the HIR declaration of the closure
715 /// - `body`: the body of the closure
716 /// - `expected_sig`: the expected signature (if any). Note that
717 /// this is missing a binder: that is, there may be late-bound
718 /// regions with depth 1, which are bound then by the closure.
719 #[instrument(skip(self, expr_def_id, decl), level = "debug")]
720 fn sig_of_closure_with_expectation(
721 &self,
722 expr_def_id: LocalDefId,
723 decl: &hir::FnDecl<'tcx>,
724 closure_kind: hir::ClosureKind,
725 expected_sig: ExpectedSig<'tcx>,
726 ) -> ClosureSignatures<'tcx> {
727 // Watch out for some surprises and just ignore the
728 // expectation if things don't see to match up with what we
729 // expect.
730 if expected_sig.sig.c_variadic() != decl.c_variadic {
731 return self.sig_of_closure_no_expectation(expr_def_id, decl, closure_kind);
732 } else if expected_sig.sig.skip_binder().inputs_and_output.len() != decl.inputs.len() + 1 {
733 return self.sig_of_closure_with_mismatched_number_of_arguments(
734 expr_def_id,
735 decl,
736 expected_sig,
737 );
738 }
739
740 // Create a `PolyFnSig`. Note the oddity that late bound
741 // regions appearing free in `expected_sig` are now bound up
742 // in this binder we are creating.
743 assert!(!expected_sig.sig.skip_binder().has_vars_bound_above(ty::INNERMOST));
744 let bound_sig = expected_sig.sig.map_bound(|sig| {
745 self.tcx.mk_fn_sig(
746 sig.inputs().iter().cloned(),
747 sig.output(),
748 sig.c_variadic,
749 hir::Safety::Safe,
750 ExternAbi::RustCall,
751 )
752 });
753
754 // `deduce_expectations_from_expected_type` introduces
755 // late-bound lifetimes defined elsewhere, which we now
756 // anonymize away, so as not to confuse the user.
757 let bound_sig = self.tcx.anonymize_bound_vars(bound_sig);
758
759 let closure_sigs = self.closure_sigs(expr_def_id, bound_sig);
760
761 // Up till this point, we have ignored the annotations that the user
762 // gave. This function will check that they unify successfully.
763 // Along the way, it also writes out entries for types that the user
764 // wrote into our typeck results, which are then later used by the privacy
765 // check.
766 match self.merge_supplied_sig_with_expectation(
767 expr_def_id,
768 decl,
769 closure_kind,
770 closure_sigs,
771 ) {
772 Ok(infer_ok) => self.register_infer_ok_obligations(infer_ok),
773 Err(_) => self.sig_of_closure_no_expectation(expr_def_id, decl, closure_kind),
774 }
775 }
776
777 fn sig_of_closure_with_mismatched_number_of_arguments(
778 &self,
779 expr_def_id: LocalDefId,
780 decl: &hir::FnDecl<'tcx>,
781 expected_sig: ExpectedSig<'tcx>,
782 ) -> ClosureSignatures<'tcx> {
783 let expr_map_node = self.tcx.hir_node_by_def_id(expr_def_id);
784 let expected_args: Vec<_> = expected_sig
785 .sig
786 .skip_binder()
787 .inputs()
788 .iter()
789 .map(|ty| ArgKind::from_expected_ty(*ty, None))
790 .collect();
791 let (closure_span, closure_arg_span, found_args) =
792 match self.err_ctxt().get_fn_like_arguments(expr_map_node) {
793 Some((sp, arg_sp, args)) => (Some(sp), arg_sp, args),
794 None => (None, None, Vec::new()),
795 };
796 let expected_span =
797 expected_sig.cause_span.unwrap_or_else(|| self.tcx.def_span(expr_def_id));
798 let guar = self
799 .err_ctxt()
800 .report_arg_count_mismatch(
801 expected_span,
802 closure_span,
803 expected_args,
804 found_args,
805 true,
806 closure_arg_span,
807 )
808 .emit();
809
810 let error_sig = self.error_sig_of_closure(decl, guar);
811
812 self.closure_sigs(expr_def_id, error_sig)
813 }
814
815 /// Enforce the user's types against the expectation. See
816 /// `sig_of_closure_with_expectation` for details on the overall
817 /// strategy.
818 #[instrument(level = "debug", skip(self, expr_def_id, decl, expected_sigs))]
819 fn merge_supplied_sig_with_expectation(
820 &self,
821 expr_def_id: LocalDefId,
822 decl: &hir::FnDecl<'tcx>,
823 closure_kind: hir::ClosureKind,
824 mut expected_sigs: ClosureSignatures<'tcx>,
825 ) -> InferResult<'tcx, ClosureSignatures<'tcx>> {
826 // Get the signature S that the user gave.
827 //
828 // (See comment on `sig_of_closure_with_expectation` for the
829 // meaning of these letters.)
830 let supplied_sig = self.supplied_sig_of_closure(expr_def_id, decl, closure_kind);
831
832 debug!(?supplied_sig);
833
834 // FIXME(#45727): As discussed in [this comment][c1], naively
835 // forcing equality here actually results in suboptimal error
836 // messages in some cases. For now, if there would have been
837 // an obvious error, we fallback to declaring the type of the
838 // closure to be the one the user gave, which allows other
839 // error message code to trigger.
840 //
841 // However, I think [there is potential to do even better
842 // here][c2], since in *this* code we have the precise span of
843 // the type parameter in question in hand when we report the
844 // error.
845 //
846 // [c1]: https://github.com/rust-lang/rust/pull/45072#issuecomment-341089706
847 // [c2]: https://github.com/rust-lang/rust/pull/45072#issuecomment-341096796
848 self.commit_if_ok(|_| {
849 let mut all_obligations = PredicateObligations::new();
850 let supplied_sig = self.instantiate_binder_with_fresh_vars(
851 self.tcx.def_span(expr_def_id),
852 BoundRegionConversionTime::FnCall,
853 supplied_sig,
854 );
855
856 // The liberated version of this signature should be a subtype
857 // of the liberated form of the expectation.
858 for ((hir_ty, &supplied_ty), expected_ty) in iter::zip(
859 iter::zip(decl.inputs, supplied_sig.inputs()),
860 expected_sigs.liberated_sig.inputs(), // `liberated_sig` is E'.
861 ) {
862 // Check that E' = S'.
863 let cause = self.misc(hir_ty.span);
864 let InferOk { value: (), obligations } = self.at(&cause, self.param_env).eq(
865 DefineOpaqueTypes::Yes,
866 *expected_ty,
867 supplied_ty,
868 )?;
869 all_obligations.extend(obligations);
870 }
871
872 let supplied_output_ty = supplied_sig.output();
873 let cause = &self.misc(decl.output.span());
874 let InferOk { value: (), obligations } = self.at(cause, self.param_env).eq(
875 DefineOpaqueTypes::Yes,
876 expected_sigs.liberated_sig.output(),
877 supplied_output_ty,
878 )?;
879 all_obligations.extend(obligations);
880
881 let inputs =
882 supplied_sig.inputs().into_iter().map(|&ty| self.resolve_vars_if_possible(ty));
883
884 expected_sigs.liberated_sig = self.tcx.mk_fn_sig(
885 inputs,
886 supplied_output_ty,
887 expected_sigs.liberated_sig.c_variadic,
888 hir::Safety::Safe,
889 ExternAbi::RustCall,
890 );
891
892 Ok(InferOk { value: expected_sigs, obligations: all_obligations })
893 })
894 }
895
896 /// If there is no expected signature, then we will convert the
897 /// types that the user gave into a signature.
898 ///
899 /// Also, record this closure signature for later.
900 #[instrument(skip(self, decl), level = "debug", ret)]
901 fn supplied_sig_of_closure(
902 &self,
903 expr_def_id: LocalDefId,
904 decl: &hir::FnDecl<'tcx>,
905 closure_kind: hir::ClosureKind,
906 ) -> ty::PolyFnSig<'tcx> {
907 let lowerer = self.lowerer();
908
909 trace!("decl = {:#?}", decl);
910 debug!(?closure_kind);
911
912 let hir_id = self.tcx.local_def_id_to_hir_id(expr_def_id);
913 let bound_vars = self.tcx.late_bound_vars(hir_id);
914
915 // First, convert the types that the user supplied (if any).
916 let supplied_arguments = decl.inputs.iter().map(|a| lowerer.lower_ty(a));
917 let supplied_return = match decl.output {
918 hir::FnRetTy::Return(ref output) => lowerer.lower_ty(output),
919 hir::FnRetTy::DefaultReturn(_) => match closure_kind {
920 // In the case of the async block that we create for a function body,
921 // we expect the return type of the block to match that of the enclosing
922 // function.
923 hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
924 hir::CoroutineDesugaring::Async,
925 hir::CoroutineSource::Fn,
926 )) => {
927 debug!("closure is async fn body");
928 self.deduce_future_output_from_obligations(expr_def_id).unwrap_or_else(|| {
929 // AFAIK, deducing the future output
930 // always succeeds *except* in error cases
931 // like #65159. I'd like to return Error
932 // here, but I can't because I can't
933 // easily (and locally) prove that we
934 // *have* reported an
935 // error. --nikomatsakis
936 lowerer.ty_infer(None, decl.output.span())
937 })
938 }
939 // All `gen {}` and `async gen {}` must return unit.
940 hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
941 hir::CoroutineDesugaring::Gen | hir::CoroutineDesugaring::AsyncGen,
942 _,
943 )) => self.tcx.types.unit,
944
945 // For async blocks, we just fall back to `_` here.
946 // For closures/coroutines, we know nothing about the return
947 // type unless it was supplied.
948 hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
949 hir::CoroutineDesugaring::Async,
950 _,
951 ))
952 | hir::ClosureKind::Coroutine(hir::CoroutineKind::Coroutine(_))
953 | hir::ClosureKind::Closure
954 | hir::ClosureKind::CoroutineClosure(_) => {
955 lowerer.ty_infer(None, decl.output.span())
956 }
957 },
958 };
959
960 let result = ty::Binder::bind_with_vars(
961 self.tcx.mk_fn_sig(
962 supplied_arguments,
963 supplied_return,
964 decl.c_variadic,
965 hir::Safety::Safe,
966 ExternAbi::RustCall,
967 ),
968 bound_vars,
969 );
970
971 let c_result = self.infcx.canonicalize_response(result);
972 self.typeck_results.borrow_mut().user_provided_sigs.insert(expr_def_id, c_result);
973
974 // Normalize only after registering in `user_provided_sigs`.
975 self.normalize(self.tcx.def_span(expr_def_id), result)
976 }
977
978 /// Invoked when we are translating the coroutine that results
979 /// from desugaring an `async fn`. Returns the "sugared" return
980 /// type of the `async fn` -- that is, the return type that the
981 /// user specified. The "desugared" return type is an `impl
982 /// Future<Output = T>`, so we do this by searching through the
983 /// obligations to extract the `T`.
984 #[instrument(skip(self), level = "debug", ret)]
985 fn deduce_future_output_from_obligations(&self, body_def_id: LocalDefId) -> Option<Ty<'tcx>> {
986 let ret_coercion = self.ret_coercion.as_ref().unwrap_or_else(|| {
987 span_bug!(self.tcx.def_span(body_def_id), "async fn coroutine outside of a fn")
988 });
989
990 let closure_span = self.tcx.def_span(body_def_id);
991 let ret_ty = ret_coercion.borrow().expected_ty();
992 let ret_ty = self.try_structurally_resolve_type(closure_span, ret_ty);
993
994 let get_future_output = |predicate: ty::Predicate<'tcx>, span| {
995 // Search for a pending obligation like
996 //
997 // `<R as Future>::Output = T`
998 //
999 // where R is the return type we are expecting. This type `T`
1000 // will be our output.
1001 let bound_predicate = predicate.kind();
1002 if let ty::PredicateKind::Clause(ty::ClauseKind::Projection(proj_predicate)) =
1003 bound_predicate.skip_binder()
1004 {
1005 self.deduce_future_output_from_projection(
1006 span,
1007 bound_predicate.rebind(proj_predicate),
1008 )
1009 } else {
1010 None
1011 }
1012 };
1013
1014 let output_ty = match *ret_ty.kind() {
1015 ty::Infer(ty::TyVar(ret_vid)) => {
1016 self.obligations_for_self_ty(ret_vid).into_iter().find_map(|obligation| {
1017 get_future_output(obligation.predicate, obligation.cause.span)
1018 })?
1019 }
1020 ty::Alias(ty::Projection, _) => {
1021 return Some(Ty::new_error_with_message(
1022 self.tcx,
1023 closure_span,
1024 "this projection should have been projected to an opaque type",
1025 ));
1026 }
1027 ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => self
1028 .tcx
1029 .explicit_item_self_bounds(def_id)
1030 .iter_instantiated_copied(self.tcx, args)
1031 .find_map(|(p, s)| get_future_output(p.as_predicate(), s))?,
1032 ty::Error(_) => return Some(ret_ty),
1033 _ => {
1034 span_bug!(closure_span, "invalid async fn coroutine return type: {ret_ty:?}")
1035 }
1036 };
1037
1038 let output_ty = self.normalize(closure_span, output_ty);
1039
1040 // async fn that have opaque types in their return type need to redo the conversion to inference variables
1041 // as they fetch the still opaque version from the signature.
1042 let InferOk { value: output_ty, obligations } = self
1043 .replace_opaque_types_with_inference_vars(
1044 output_ty,
1045 body_def_id,
1046 closure_span,
1047 self.param_env,
1048 );
1049 self.register_predicates(obligations);
1050
1051 Some(output_ty)
1052 }
1053
1054 /// Given a projection like
1055 ///
1056 /// `<X as Future>::Output = T`
1057 ///
1058 /// where `X` is some type that has no late-bound regions, returns
1059 /// `Some(T)`. If the projection is for some other trait, returns
1060 /// `None`.
1061 fn deduce_future_output_from_projection(
1062 &self,
1063 cause_span: Span,
1064 predicate: ty::PolyProjectionPredicate<'tcx>,
1065 ) -> Option<Ty<'tcx>> {
1066 debug!("deduce_future_output_from_projection(predicate={:?})", predicate);
1067
1068 // We do not expect any bound regions in our predicate, so
1069 // skip past the bound vars.
1070 let Some(predicate) = predicate.no_bound_vars() else {
1071 debug!("deduce_future_output_from_projection: has late-bound regions");
1072 return None;
1073 };
1074
1075 // Check that this is a projection from the `Future` trait.
1076 let trait_def_id = predicate.projection_term.trait_def_id(self.tcx);
1077 if !self.tcx.is_lang_item(trait_def_id, LangItem::Future) {
1078 debug!("deduce_future_output_from_projection: not a future");
1079 return None;
1080 }
1081
1082 // The `Future` trait has only one associated item, `Output`,
1083 // so check that this is what we see.
1084 let output_assoc_item = self.tcx.associated_item_def_ids(trait_def_id)[0];
1085 if output_assoc_item != predicate.projection_term.def_id {
1086 span_bug!(
1087 cause_span,
1088 "projecting associated item `{:?}` from future, which is not Output `{:?}`",
1089 predicate.projection_term.def_id,
1090 output_assoc_item,
1091 );
1092 }
1093
1094 // Extract the type from the projection. Note that there can
1095 // be no bound variables in this type because the "self type"
1096 // does not have any regions in it.
1097 let output_ty = self.resolve_vars_if_possible(predicate.term);
1098 debug!("deduce_future_output_from_projection: output_ty={:?}", output_ty);
1099 // This is a projection on a Fn trait so will always be a type.
1100 Some(output_ty.expect_type())
1101 }
1102
1103 /// Converts the types that the user supplied, in case that doing
1104 /// so should yield an error, but returns back a signature where
1105 /// all parameters are of type `ty::Error`.
1106 fn error_sig_of_closure(
1107 &self,
1108 decl: &hir::FnDecl<'tcx>,
1109 guar: ErrorGuaranteed,
1110 ) -> ty::PolyFnSig<'tcx> {
1111 let lowerer = self.lowerer();
1112 let err_ty = Ty::new_error(self.tcx, guar);
1113
1114 let supplied_arguments = decl.inputs.iter().map(|a| {
1115 // Convert the types that the user supplied (if any), but ignore them.
1116 lowerer.lower_ty(a);
1117 err_ty
1118 });
1119
1120 if let hir::FnRetTy::Return(ref output) = decl.output {
1121 lowerer.lower_ty(output);
1122 }
1123
1124 let result = ty::Binder::dummy(self.tcx.mk_fn_sig(
1125 supplied_arguments,
1126 err_ty,
1127 decl.c_variadic,
1128 hir::Safety::Safe,
1129 ExternAbi::RustCall,
1130 ));
1131
1132 debug!("supplied_sig_of_closure: result={:?}", result);
1133
1134 result
1135 }
1136
1137 #[instrument(level = "debug", skip(self), ret)]
1138 fn closure_sigs(
1139 &self,
1140 expr_def_id: LocalDefId,
1141 bound_sig: ty::PolyFnSig<'tcx>,
1142 ) -> ClosureSignatures<'tcx> {
1143 let liberated_sig =
1144 self.tcx().liberate_late_bound_regions(expr_def_id.to_def_id(), bound_sig);
1145 let liberated_sig = self.normalize(self.tcx.def_span(expr_def_id), liberated_sig);
1146 ClosureSignatures { bound_sig, liberated_sig }
1147 }
1148}