| //! This calculates the types which has storage which lives across a suspension point in a |
| //! generator from the perspective of typeck. The actual types used at runtime |
| //! is calculated in `rustc_mir_transform::generator` and may be a subset of the |
| //! types computed here. |
| |
| use self::drop_ranges::DropRanges; |
| use super::FnCtxt; |
| use rustc_data_structures::fx::{FxHashSet, FxIndexSet}; |
| use rustc_errors::{pluralize, DelayDm}; |
| use rustc_hir as hir; |
| use rustc_hir::def::{CtorKind, DefKind, Res}; |
| use rustc_hir::def_id::DefId; |
| use rustc_hir::hir_id::HirIdSet; |
| use rustc_hir::intravisit::{self, Visitor}; |
| use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind}; |
| use rustc_infer::infer::{DefineOpaqueTypes, RegionVariableOrigin}; |
| use rustc_middle::middle::region::{self, Scope, ScopeData, YieldData}; |
| use rustc_middle::ty::fold::FnMutDelegate; |
| use rustc_middle::ty::{self, BoundVariableKind, RvalueScopes, Ty, TyCtxt, TypeVisitableExt}; |
| use rustc_span::symbol::sym; |
| use rustc_span::Span; |
| use smallvec::{smallvec, SmallVec}; |
| |
| mod drop_ranges; |
| |
| struct InteriorVisitor<'a, 'tcx> { |
| fcx: &'a FnCtxt<'a, 'tcx>, |
| region_scope_tree: &'a region::ScopeTree, |
| types: FxIndexSet<ty::GeneratorInteriorTypeCause<'tcx>>, |
| rvalue_scopes: &'a RvalueScopes, |
| expr_count: usize, |
| kind: hir::GeneratorKind, |
| prev_unresolved_span: Option<Span>, |
| linted_values: HirIdSet, |
| drop_ranges: DropRanges, |
| } |
| |
| impl<'a, 'tcx> InteriorVisitor<'a, 'tcx> { |
| fn record( |
| &mut self, |
| ty: Ty<'tcx>, |
| hir_id: HirId, |
| scope: Option<region::Scope>, |
| expr: Option<&'tcx Expr<'tcx>>, |
| source_span: Span, |
| ) { |
| use rustc_span::DUMMY_SP; |
| |
| let ty = self.fcx.resolve_vars_if_possible(ty); |
| |
| debug!( |
| "attempting to record type ty={:?}; hir_id={:?}; scope={:?}; expr={:?}; source_span={:?}; expr_count={:?}", |
| ty, hir_id, scope, expr, source_span, self.expr_count, |
| ); |
| |
| let live_across_yield = scope |
| .map(|s| { |
| self.region_scope_tree.yield_in_scope(s).and_then(|yield_data| { |
| // If we are recording an expression that is the last yield |
| // in the scope, or that has a postorder CFG index larger |
| // than the one of all of the yields, then its value can't |
| // be storage-live (and therefore live) at any of the yields. |
| // |
| // See the mega-comment at `yield_in_scope` for a proof. |
| |
| yield_data |
| .iter() |
| .find(|yield_data| { |
| debug!( |
| "comparing counts yield: {} self: {}, source_span = {:?}", |
| yield_data.expr_and_pat_count, self.expr_count, source_span |
| ); |
| |
| if self |
| .is_dropped_at_yield_location(hir_id, yield_data.expr_and_pat_count) |
| { |
| debug!("value is dropped at yield point; not recording"); |
| return false; |
| } |
| |
| // If it is a borrowing happening in the guard, |
| // it needs to be recorded regardless because they |
| // do live across this yield point. |
| yield_data.expr_and_pat_count >= self.expr_count |
| }) |
| .cloned() |
| }) |
| }) |
| .unwrap_or_else(|| { |
| Some(YieldData { span: DUMMY_SP, expr_and_pat_count: 0, source: self.kind.into() }) |
| }); |
| |
| if let Some(yield_data) = live_across_yield { |
| debug!( |
| "type in expr = {:?}, scope = {:?}, type = {:?}, count = {}, yield_span = {:?}", |
| expr, scope, ty, self.expr_count, yield_data.span |
| ); |
| |
| if let Some((unresolved_term, unresolved_type_span)) = |
| self.fcx.first_unresolved_const_or_ty_var(&ty) |
| { |
| // If unresolved type isn't a ty_var then unresolved_type_span is None |
| let span = self |
| .prev_unresolved_span |
| .unwrap_or_else(|| unresolved_type_span.unwrap_or(source_span)); |
| |
| // If we encounter an int/float variable, then inference fallback didn't |
| // finish due to some other error. Don't emit spurious additional errors. |
| if let Some(unresolved_ty) = unresolved_term.ty() |
| && let ty::Infer(ty::InferTy::IntVar(_) | ty::InferTy::FloatVar(_)) = unresolved_ty.kind() |
| { |
| self.fcx |
| .tcx |
| .sess |
| .delay_span_bug(span, format!("Encountered var {unresolved_term:?}")); |
| } else { |
| let note = format!( |
| "the type is part of the {} because of this {}", |
| self.kind.descr(), |
| yield_data.source |
| ); |
| |
| self.fcx |
| .need_type_info_err_in_generator(self.kind, span, unresolved_term) |
| .span_note(yield_data.span, note) |
| .emit(); |
| } |
| } else { |
| // Insert the type into the ordered set. |
| let scope_span = scope.map(|s| s.span(self.fcx.tcx, self.region_scope_tree)); |
| |
| if !self.linted_values.contains(&hir_id) { |
| check_must_not_suspend_ty( |
| self.fcx, |
| ty, |
| hir_id, |
| SuspendCheckData { |
| expr, |
| source_span, |
| yield_span: yield_data.span, |
| plural_len: 1, |
| ..Default::default() |
| }, |
| ); |
| self.linted_values.insert(hir_id); |
| } |
| |
| self.types.insert(ty::GeneratorInteriorTypeCause { |
| span: source_span, |
| ty, |
| scope_span, |
| yield_span: yield_data.span, |
| expr: expr.map(|e| e.hir_id), |
| }); |
| } |
| } else { |
| debug!( |
| "no type in expr = {:?}, count = {:?}, span = {:?}", |
| expr, |
| self.expr_count, |
| expr.map(|e| e.span) |
| ); |
| if let Some((unresolved_type, unresolved_type_span)) = |
| self.fcx.first_unresolved_const_or_ty_var(&ty) |
| { |
| debug!( |
| "remained unresolved_type = {:?}, unresolved_type_span: {:?}", |
| unresolved_type, unresolved_type_span |
| ); |
| self.prev_unresolved_span = unresolved_type_span; |
| } |
| } |
| } |
| |
| /// If drop tracking is enabled, consult drop_ranges to see if a value is |
| /// known to be dropped at a yield point and therefore can be omitted from |
| /// the generator witness. |
| fn is_dropped_at_yield_location(&self, value_hir_id: HirId, yield_location: usize) -> bool { |
| // short-circuit if drop tracking is not enabled. |
| if !self.fcx.sess().opts.unstable_opts.drop_tracking { |
| return false; |
| } |
| |
| self.drop_ranges.is_dropped_at(value_hir_id, yield_location) |
| } |
| } |
| |
| pub fn resolve_interior<'a, 'tcx>( |
| fcx: &'a FnCtxt<'a, 'tcx>, |
| def_id: DefId, |
| body_id: hir::BodyId, |
| interior: Ty<'tcx>, |
| kind: hir::GeneratorKind, |
| ) { |
| let body = fcx.tcx.hir().body(body_id); |
| let typeck_results = fcx.inh.typeck_results.borrow(); |
| let mut visitor = InteriorVisitor { |
| fcx, |
| types: FxIndexSet::default(), |
| region_scope_tree: fcx.tcx.region_scope_tree(def_id), |
| rvalue_scopes: &typeck_results.rvalue_scopes, |
| expr_count: 0, |
| kind, |
| prev_unresolved_span: None, |
| linted_values: <_>::default(), |
| drop_ranges: drop_ranges::compute_drop_ranges(fcx, def_id, body), |
| }; |
| intravisit::walk_body(&mut visitor, body); |
| |
| // Check that we visited the same amount of expressions as the RegionResolutionVisitor |
| let region_expr_count = fcx.tcx.region_scope_tree(def_id).body_expr_count(body_id).unwrap(); |
| assert_eq!(region_expr_count, visitor.expr_count); |
| |
| // The types are already kept in insertion order. |
| let types = visitor.types; |
| |
| // The types in the generator interior contain lifetimes local to the generator itself, |
| // which should not be exposed outside of the generator. Therefore, we replace these |
| // lifetimes with existentially-bound lifetimes, which reflect the exact value of the |
| // lifetimes not being known by users. |
| // |
| // These lifetimes are used in auto trait impl checking (for example, |
| // if a Sync generator contains an &'α T, we need to check whether &'α T: Sync), |
| // so knowledge of the exact relationships between them isn't particularly important. |
| |
| debug!("types in generator {:?}, span = {:?}", types, body.value.span); |
| |
| // We want to deduplicate if the lifetimes are the same modulo some non-informative counter. |
| // So, we need to actually do two passes: first by type to anonymize (preserving information |
| // required for diagnostics), then a second pass over all captured types to reassign disjoint |
| // region indices. |
| let mut captured_tys = FxHashSet::default(); |
| let type_causes: Vec<_> = types |
| .into_iter() |
| .filter_map(|mut cause| { |
| // Replace all regions inside the generator interior with late bound regions. |
| // Note that each region slot in the types gets a new fresh late bound region, |
| // which means that none of the regions inside relate to any other, even if |
| // typeck had previously found constraints that would cause them to be related. |
| |
| let mut counter = 0; |
| let mut mk_bound_region = |kind| { |
| let var = ty::BoundVar::from_u32(counter); |
| counter += 1; |
| ty::BoundRegion { var, kind } |
| }; |
| let ty = fcx.normalize(cause.span, cause.ty); |
| let ty = fcx.tcx.fold_regions(ty, |region, current_depth| { |
| let br = match region.kind() { |
| ty::ReVar(vid) => { |
| let origin = fcx.region_var_origin(vid); |
| match origin { |
| RegionVariableOrigin::EarlyBoundRegion(span, _) => { |
| mk_bound_region(ty::BrAnon(Some(span))) |
| } |
| _ => mk_bound_region(ty::BrAnon(None)), |
| } |
| } |
| ty::ReEarlyBound(region) => { |
| mk_bound_region(ty::BrNamed(region.def_id, region.name)) |
| } |
| ty::ReLateBound(_, ty::BoundRegion { kind, .. }) |
| | ty::ReFree(ty::FreeRegion { bound_region: kind, .. }) => match kind { |
| ty::BoundRegionKind::BrAnon(span) => mk_bound_region(ty::BrAnon(span)), |
| ty::BoundRegionKind::BrNamed(def_id, sym) => { |
| mk_bound_region(ty::BrNamed(def_id, sym)) |
| } |
| ty::BoundRegionKind::BrEnv => mk_bound_region(ty::BrAnon(None)), |
| }, |
| _ => mk_bound_region(ty::BrAnon(None)), |
| }; |
| let r = ty::Region::new_late_bound(fcx.tcx, current_depth, br); |
| r |
| }); |
| captured_tys.insert(ty).then(|| { |
| cause.ty = ty; |
| cause |
| }) |
| }) |
| .collect(); |
| |
| let mut bound_vars: SmallVec<[BoundVariableKind; 4]> = smallvec![]; |
| let mut counter = 0; |
| // Optimization: If there is only one captured type, then we don't actually |
| // need to fold and reindex (since the first type doesn't change). |
| let type_causes = if captured_tys.len() > 0 { |
| // Optimization: Use `replace_escaping_bound_vars_uncached` instead of |
| // `fold_regions`, since we only have late bound regions, and it skips |
| // types without bound regions. |
| fcx.tcx.replace_escaping_bound_vars_uncached( |
| type_causes, |
| FnMutDelegate { |
| regions: &mut |br| { |
| let kind = br.kind; |
| let var = ty::BoundVar::from_usize(bound_vars.len()); |
| bound_vars.push(ty::BoundVariableKind::Region(kind)); |
| counter += 1; |
| ty::Region::new_late_bound( |
| fcx.tcx, |
| ty::INNERMOST, |
| ty::BoundRegion { var, kind }, |
| ) |
| }, |
| types: &mut |b| bug!("unexpected bound ty in binder: {b:?}"), |
| consts: &mut |b, ty| bug!("unexpected bound ct in binder: {b:?} {ty}"), |
| }, |
| ) |
| } else { |
| type_causes |
| }; |
| |
| // Extract type components to build the witness type. |
| let type_list = fcx.tcx.mk_type_list_from_iter(type_causes.iter().map(|cause| cause.ty)); |
| let bound_vars = fcx.tcx.mk_bound_variable_kinds(&bound_vars); |
| let witness = |
| Ty::new_generator_witness(fcx.tcx, ty::Binder::bind_with_vars(type_list, bound_vars)); |
| |
| drop(typeck_results); |
| // Store the generator types and spans into the typeck results for this generator. |
| fcx.inh.typeck_results.borrow_mut().generator_interior_types = |
| ty::Binder::bind_with_vars(type_causes, bound_vars); |
| |
| debug!( |
| "types in generator after region replacement {:?}, span = {:?}", |
| witness, body.value.span |
| ); |
| |
| // Unify the type variable inside the generator with the new witness |
| match fcx.at(&fcx.misc(body.value.span), fcx.param_env).eq( |
| DefineOpaqueTypes::No, |
| interior, |
| witness, |
| ) { |
| Ok(ok) => fcx.register_infer_ok_obligations(ok), |
| _ => bug!("failed to relate {interior} and {witness}"), |
| } |
| } |
| |
| // This visitor has to have the same visit_expr calls as RegionResolutionVisitor in |
| // librustc_middle/middle/region.rs since `expr_count` is compared against the results |
| // there. |
| impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { |
| fn visit_arm(&mut self, arm: &'tcx Arm<'tcx>) { |
| let Arm { guard, pat, body, .. } = arm; |
| self.visit_pat(pat); |
| if let Some(ref g) = guard { |
| { |
| // If there is a guard, we need to count all variables bound in the pattern as |
| // borrowed for the entire guard body, regardless of whether they are accessed. |
| // We do this by walking the pattern bindings and recording `&T` for any `x: T` |
| // that is bound. |
| |
| struct ArmPatCollector<'a, 'b, 'tcx> { |
| interior_visitor: &'a mut InteriorVisitor<'b, 'tcx>, |
| scope: Scope, |
| } |
| |
| impl<'a, 'b, 'tcx> Visitor<'tcx> for ArmPatCollector<'a, 'b, 'tcx> { |
| fn visit_pat(&mut self, pat: &'tcx Pat<'tcx>) { |
| intravisit::walk_pat(self, pat); |
| if let PatKind::Binding(_, id, ident, ..) = pat.kind { |
| let ty = |
| self.interior_visitor.fcx.typeck_results.borrow().node_type(id); |
| let tcx = self.interior_visitor.fcx.tcx; |
| let ty = Ty::new_ref( |
| tcx, |
| // Use `ReErased` as `resolve_interior` is going to replace all the |
| // regions anyway. |
| tcx.lifetimes.re_erased, |
| ty::TypeAndMut { ty, mutbl: hir::Mutability::Not }, |
| ); |
| self.interior_visitor.record( |
| ty, |
| id, |
| Some(self.scope), |
| None, |
| ident.span, |
| ); |
| } |
| } |
| } |
| |
| ArmPatCollector { |
| interior_visitor: self, |
| scope: Scope { id: g.body().hir_id.local_id, data: ScopeData::Node }, |
| } |
| .visit_pat(pat); |
| } |
| |
| match g { |
| Guard::If(ref e) => { |
| self.visit_expr(e); |
| } |
| Guard::IfLet(ref l) => { |
| self.visit_let_expr(l); |
| } |
| } |
| } |
| self.visit_expr(body); |
| } |
| |
| fn visit_pat(&mut self, pat: &'tcx Pat<'tcx>) { |
| intravisit::walk_pat(self, pat); |
| |
| self.expr_count += 1; |
| |
| if let PatKind::Binding(..) = pat.kind { |
| let scope = self.region_scope_tree.var_scope(pat.hir_id.local_id).unwrap(); |
| let ty = self.fcx.typeck_results.borrow().pat_ty(pat); |
| self.record(ty, pat.hir_id, Some(scope), None, pat.span); |
| } |
| } |
| |
| fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) { |
| match &expr.kind { |
| ExprKind::Call(callee, args) => match &callee.kind { |
| ExprKind::Path(qpath) => { |
| let res = self.fcx.typeck_results.borrow().qpath_res(qpath, callee.hir_id); |
| match res { |
| // Direct calls never need to keep the callee `ty::FnDef` |
| // ZST in a temporary, so skip its type, just in case it |
| // can significantly complicate the generator type. |
| Res::Def( |
| DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(_, CtorKind::Fn), |
| _, |
| ) => { |
| // NOTE(eddyb) this assumes a path expression has |
| // no nested expressions to keep track of. |
| self.expr_count += 1; |
| |
| // Record the rest of the call expression normally. |
| for arg in *args { |
| self.visit_expr(arg); |
| } |
| } |
| _ => intravisit::walk_expr(self, expr), |
| } |
| } |
| _ => intravisit::walk_expr(self, expr), |
| }, |
| _ => intravisit::walk_expr(self, expr), |
| } |
| |
| self.expr_count += 1; |
| |
| debug!("is_borrowed_temporary: {:?}", self.drop_ranges.is_borrowed_temporary(expr)); |
| |
| let ty = self.fcx.typeck_results.borrow().expr_ty_adjusted_opt(expr); |
| |
| // Typically, the value produced by an expression is consumed by its parent in some way, |
| // so we only have to check if the parent contains a yield (note that the parent may, for |
| // example, store the value into a local variable, but then we already consider local |
| // variables to be live across their scope). |
| // |
| // However, in the case of temporary values, we are going to store the value into a |
| // temporary on the stack that is live for the current temporary scope and then return a |
| // reference to it. That value may be live across the entire temporary scope. |
| // |
| // There's another subtlety: if the type has an observable drop, it must be dropped after |
| // the yield, even if it's not borrowed or referenced after the yield. Ideally this would |
| // *only* happen for types with observable drop, not all types which wrap them, but that |
| // doesn't match the behavior of MIR borrowck and causes ICEs. See the FIXME comment in |
| // tests/ui/generator/drop-tracking-parent-expression.rs. |
| let scope = if self.drop_ranges.is_borrowed_temporary(expr) |
| || ty.map_or(true, |ty| { |
| // Avoid ICEs in needs_drop. |
| let ty = self.fcx.resolve_vars_if_possible(ty); |
| let ty = self.fcx.tcx.erase_regions(ty); |
| if ty.has_infer() { |
| self.fcx |
| .tcx |
| .sess |
| .delay_span_bug(expr.span, format!("inference variables in {ty}")); |
| true |
| } else { |
| ty.needs_drop(self.fcx.tcx, self.fcx.param_env) |
| } |
| }) { |
| self.rvalue_scopes.temporary_scope(self.region_scope_tree, expr.hir_id.local_id) |
| } else { |
| let parent_expr = self |
| .fcx |
| .tcx |
| .hir() |
| .parent_iter(expr.hir_id) |
| .find(|(_, node)| matches!(node, hir::Node::Expr(_))) |
| .map(|(id, _)| id); |
| debug!("parent_expr: {:?}", parent_expr); |
| match parent_expr { |
| Some(parent) => Some(Scope { id: parent.local_id, data: ScopeData::Node }), |
| None => { |
| self.rvalue_scopes.temporary_scope(self.region_scope_tree, expr.hir_id.local_id) |
| } |
| } |
| }; |
| |
| // If there are adjustments, then record the final type -- |
| // this is the actual value that is being produced. |
| if let Some(adjusted_ty) = ty { |
| self.record(adjusted_ty, expr.hir_id, scope, Some(expr), expr.span); |
| } |
| |
| // Also record the unadjusted type (which is the only type if |
| // there are no adjustments). The reason for this is that the |
| // unadjusted value is sometimes a "temporary" that would wind |
| // up in a MIR temporary. |
| // |
| // As an example, consider an expression like `vec![].push(x)`. |
| // Here, the `vec![]` would wind up MIR stored into a |
| // temporary variable `t` which we can borrow to invoke |
| // `<Vec<_>>::push(&mut t, x)`. |
| // |
| // Note that an expression can have many adjustments, and we |
| // are just ignoring those intermediate types. This is because |
| // those intermediate values are always linearly "consumed" by |
| // the other adjustments, and hence would never be directly |
| // captured in the MIR. |
| // |
| // (Note that this partly relies on the fact that the `Deref` |
| // traits always return references, which means their content |
| // can be reborrowed without needing to spill to a temporary. |
| // If this were not the case, then we could conceivably have |
| // to create intermediate temporaries.) |
| // |
| // The type table might not have information for this expression |
| // if it is in a malformed scope. (#66387) |
| if let Some(ty) = self.fcx.typeck_results.borrow().expr_ty_opt(expr) { |
| self.record(ty, expr.hir_id, scope, Some(expr), expr.span); |
| } else { |
| self.fcx.tcx.sess.delay_span_bug(expr.span, "no type for node"); |
| } |
| } |
| } |
| |
| #[derive(Default)] |
| struct SuspendCheckData<'a, 'tcx> { |
| expr: Option<&'tcx Expr<'tcx>>, |
| source_span: Span, |
| yield_span: Span, |
| descr_pre: &'a str, |
| descr_post: &'a str, |
| plural_len: usize, |
| } |
| |
| // Returns whether it emitted a diagnostic or not |
| // Note that this fn and the proceeding one are based on the code |
| // for creating must_use diagnostics |
| // |
| // Note that this technique was chosen over things like a `Suspend` marker trait |
| // as it is simpler and has precedent in the compiler |
| fn check_must_not_suspend_ty<'tcx>( |
| fcx: &FnCtxt<'_, 'tcx>, |
| ty: Ty<'tcx>, |
| hir_id: HirId, |
| data: SuspendCheckData<'_, 'tcx>, |
| ) -> bool { |
| if ty.is_unit() |
| // FIXME: should this check `Ty::is_inhabited_from`. This query is not available in this stage |
| // of typeck (before ReVar and RePlaceholder are removed), but may remove noise, like in |
| // `must_use` |
| // || !ty.is_inhabited_from(fcx.tcx, fcx.tcx.parent_module(hir_id).to_def_id(), fcx.param_env) |
| { |
| return false; |
| } |
| |
| let plural_suffix = pluralize!(data.plural_len); |
| |
| debug!("Checking must_not_suspend for {}", ty); |
| |
| match *ty.kind() { |
| ty::Adt(..) if ty.is_box() => { |
| let boxed_ty = ty.boxed_ty(); |
| let descr_pre = &format!("{}boxed ", data.descr_pre); |
| check_must_not_suspend_ty(fcx, boxed_ty, hir_id, SuspendCheckData { descr_pre, ..data }) |
| } |
| ty::Adt(def, _) => check_must_not_suspend_def(fcx.tcx, def.did(), hir_id, data), |
| // FIXME: support adding the attribute to TAITs |
| ty::Alias(ty::Opaque, ty::AliasTy { def_id: def, .. }) => { |
| let mut has_emitted = false; |
| for &(predicate, _) in fcx.tcx.explicit_item_bounds(def).skip_binder() { |
| // We only look at the `DefId`, so it is safe to skip the binder here. |
| if let ty::ClauseKind::Trait(ref poly_trait_predicate) = |
| predicate.kind().skip_binder() |
| { |
| let def_id = poly_trait_predicate.trait_ref.def_id; |
| let descr_pre = &format!("{}implementer{} of ", data.descr_pre, plural_suffix); |
| if check_must_not_suspend_def( |
| fcx.tcx, |
| def_id, |
| hir_id, |
| SuspendCheckData { descr_pre, ..data }, |
| ) { |
| has_emitted = true; |
| break; |
| } |
| } |
| } |
| has_emitted |
| } |
| ty::Dynamic(binder, _, _) => { |
| let mut has_emitted = false; |
| for predicate in binder.iter() { |
| if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() { |
| let def_id = trait_ref.def_id; |
| let descr_post = &format!(" trait object{}{}", plural_suffix, data.descr_post); |
| if check_must_not_suspend_def( |
| fcx.tcx, |
| def_id, |
| hir_id, |
| SuspendCheckData { descr_post, ..data }, |
| ) { |
| has_emitted = true; |
| break; |
| } |
| } |
| } |
| has_emitted |
| } |
| ty::Tuple(fields) => { |
| let mut has_emitted = false; |
| let comps = match data.expr.map(|e| &e.kind) { |
| Some(hir::ExprKind::Tup(comps)) if comps.len() == fields.len() => Some(comps), |
| _ => None, |
| }; |
| for (i, ty) in fields.iter().enumerate() { |
| let descr_post = &format!(" in tuple element {i}"); |
| let span = comps.and_then(|c| c.get(i)).map(|e| e.span).unwrap_or(data.source_span); |
| if check_must_not_suspend_ty( |
| fcx, |
| ty, |
| hir_id, |
| SuspendCheckData { |
| descr_post, |
| expr: comps.and_then(|comps| comps.get(i)), |
| source_span: span, |
| ..data |
| }, |
| ) { |
| has_emitted = true; |
| } |
| } |
| has_emitted |
| } |
| ty::Array(ty, len) => { |
| let descr_pre = &format!("{}array{} of ", data.descr_pre, plural_suffix); |
| check_must_not_suspend_ty( |
| fcx, |
| ty, |
| hir_id, |
| SuspendCheckData { |
| descr_pre, |
| plural_len: len.try_eval_target_usize(fcx.tcx, fcx.param_env).unwrap_or(0) |
| as usize |
| + 1, |
| ..data |
| }, |
| ) |
| } |
| // If drop tracking is enabled, we want to look through references, since the referent |
| // may not be considered live across the await point. |
| ty::Ref(_region, ty, _mutability) if fcx.sess().opts.unstable_opts.drop_tracking => { |
| let descr_pre = &format!("{}reference{} to ", data.descr_pre, plural_suffix); |
| check_must_not_suspend_ty(fcx, ty, hir_id, SuspendCheckData { descr_pre, ..data }) |
| } |
| _ => false, |
| } |
| } |
| |
| fn check_must_not_suspend_def( |
| tcx: TyCtxt<'_>, |
| def_id: DefId, |
| hir_id: HirId, |
| data: SuspendCheckData<'_, '_>, |
| ) -> bool { |
| if let Some(attr) = tcx.get_attr(def_id, sym::must_not_suspend) { |
| tcx.struct_span_lint_hir( |
| rustc_session::lint::builtin::MUST_NOT_SUSPEND, |
| hir_id, |
| data.source_span, |
| DelayDm(|| { |
| format!( |
| "{}`{}`{} held across a suspend point, but should not be", |
| data.descr_pre, |
| tcx.def_path_str(def_id), |
| data.descr_post, |
| ) |
| }), |
| |lint| { |
| // add span pointing to the offending yield/await |
| lint.span_label(data.yield_span, "the value is held across this suspend point"); |
| |
| // Add optional reason note |
| if let Some(note) = attr.value_str() { |
| // FIXME(guswynn): consider formatting this better |
| lint.span_note(data.source_span, note.to_string()); |
| } |
| |
| // Add some quick suggestions on what to do |
| // FIXME: can `drop` work as a suggestion here as well? |
| lint.span_help( |
| data.source_span, |
| "consider using a block (`{ ... }`) \ |
| to shrink the value's scope, ending before the suspend point", |
| ); |
| |
| lint |
| }, |
| ); |
| |
| true |
| } else { |
| false |
| } |
| } |
