compiler/rustc_hir_analysis/src/outlives/utils.rs

   1 use rustc_infer::infer::outlives::components::{push_outlives_components, Component};
   2 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
   3 use rustc_middle::ty::{self, Region, Ty, TyCtxt};
   4 use rustc_span::Span;
   5 use smallvec::smallvec;
   6 use std::collections::BTreeMap;
   7
   8 /// Tracks the `T: 'a` or `'a: 'a` predicates that we have inferred
   9 /// must be added to the struct header.
  10 pub(crate) type RequiredPredicates<'tcx> =
  11     BTreeMap<ty::OutlivesPredicate<GenericArg<'tcx>, ty::Region<'tcx>>, Span>;
  12
  13 /// Given a requirement `T: 'a` or `'b: 'a`, deduce the
  14 /// outlives_component and add it to `required_predicates`
  15 pub(crate) fn insert_outlives_predicate<'tcx>(
  16     tcx: TyCtxt<'tcx>,
  17     kind: GenericArg<'tcx>,
  18     outlived_region: Region<'tcx>,
  19     span: Span,
  20     required_predicates: &mut RequiredPredicates<'tcx>,
  21 ) {
  22     // If the `'a` region is bound within the field type itself, we
  23     // don't want to propagate this constraint to the header.
  24     if !is_free_region(outlived_region) {
  25         return;
  26     }
  27
  28     match kind.unpack() {
  29         GenericArgKind::Type(ty) => {
  30             // `T: 'outlived_region` for some type `T`
  31             // But T could be a lot of things:
  32             // e.g., if `T = &'b u32`, then `'b: 'outlived_region` is
  33             // what we want to add.
  34             //
  35             // Or if within `struct Foo<U>` you had `T = Vec<U>`, then
  36             // we would want to add `U: 'outlived_region`
  37             let mut components = smallvec![];
  38             push_outlives_components(tcx, ty, &mut components);
  39             for component in components {
  40                 match component {
  41                     Component::Region(r) => {
  42                         // This would arise from something like:
  43                         //
  44                         // ```
  45                         // struct Foo<'a, 'b> {
  46                         //    x:  &'a &'b u32
  47                         // }
  48                         // ```
  49                         //
  50                         // Here `outlived_region = 'a` and `kind = &'b
  51                         // u32`.  Decomposing `&'b u32` into
  52                         // components would yield `'b`, and we add the
  53                         // where clause that `'b: 'a`.
  54                         insert_outlives_predicate(
  55                             tcx,
  56                             r.into(),
  57                             outlived_region,
  58                             span,
  59                             required_predicates,
  60                         );
  61                     }
  62
  63                     Component::Param(param_ty) => {
  64                         // param_ty: ty::ParamTy
  65                         // This would arise from something like:
  66                         //
  67                         // ```
  68                         // struct Foo<'a, U> {
  69                         //    x:  &'a Vec<U>
  70                         // }
  71                         // ```
  72                         //
  73                         // Here `outlived_region = 'a` and `kind =
  74                         // Vec<U>`.  Decomposing `Vec<U>` into
  75                         // components would yield `U`, and we add the
  76                         // where clause that `U: 'a`.
  77                         let ty: Ty<'tcx> = param_ty.to_ty(tcx);
  78                         required_predicates
  79                             .entry(ty::OutlivesPredicate(ty.into(), outlived_region))
  80                             .or_insert(span);
  81                     }
  82
  83                     Component::Alias(kind, alias) => {
  84                         // This would either arise from something like:
  85                         //
  86                         // ```
  87                         // struct Foo<'a, T: Iterator> {
  88                         //    x:  &'a <T as Iterator>::Item
  89                         // }
  90                         // ```
  91                         //
  92                         // or:
  93                         //
  94                         // ```rust
  95                         // type Opaque<T> = impl Sized;
  96                         // fn defining<T>() -> Opaque<T> {}
  97                         // struct Ss<'a, T>(&'a Opaque<T>);
  98                         // ```
  99                         //
 100                         // Here we want to add an explicit `where <T as Iterator>::Item: 'a`
 101                         // or `Opaque<T>: 'a` depending on the alias kind.
 102                         let ty: Ty<'tcx> = tcx.mk_ty(ty::Alias(kind, alias));
 103                         required_predicates
 104                             .entry(ty::OutlivesPredicate(ty.into(), outlived_region))
 105                             .or_insert(span);
 106                     }
 107
 108                     Component::EscapingProjection(_) => {
 109                         // As above, but the projection involves
 110                         // late-bound regions.  Therefore, the WF
 111                         // requirement is not checked in type definition
 112                         // but at fn call site, so ignore it.
 113                         //
 114                         // ```
 115                         // struct Foo<'a, T: Iterator> {
 116                         //    x: for<'b> fn(<&'b T as Iterator>::Item)
 117                         //              //  ^^^^^^^^^^^^^^^^^^^^^^^^^
 118                         // }
 119                         // ```
 120                         //
 121                         // Since `'b` is not in scope on `Foo`, can't
 122                         // do anything here, ignore it.
 123                     }
 124
 125                     Component::UnresolvedInferenceVariable(_) => bug!("not using infcx"),
 126                 }
 127             }
 128         }
 129
 130         GenericArgKind::Lifetime(r) => {
 131             if !is_free_region(r) {
 132                 return;
 133             }
 134             required_predicates.entry(ty::OutlivesPredicate(kind, outlived_region)).or_insert(span);
 135         }
 136
 137         GenericArgKind::Const(_) => {
 138             // Generic consts don't impose any constraints.
 139         }
 140     }
 141 }
 142
 143 fn is_free_region(region: Region<'_>) -> bool {
 144     // First, screen for regions that might appear in a type header.
 145     match *region {
 146         // These correspond to `T: 'a` relationships:
 147         //
 148         //     struct Foo<'a, T> {
 149         //         field: &'a T, // this would generate a ReEarlyBound referencing `'a`
 150         //     }
 151         //
 152         // We care about these, so fall through.
 153         ty::ReEarlyBound(_) => true,
 154
 155         // These correspond to `T: 'static` relationships which can be
 156         // rather surprising.
 157         //
 158         //     struct Foo<'a, T> {
 159         //         field: &'static T, // this would generate a ReStatic
 160         //     }
 161         ty::ReStatic => false,
 162
 163         // Late-bound regions can appear in `fn` types:
 164         //
 165         //     struct Foo<T> {
 166         //         field: for<'b> fn(&'b T) // e.g., 'b here
 167         //     }
 168         //
 169         // The type above might generate a `T: 'b` bound, but we can
 170         // ignore it.  We can't put it on the struct header anyway.
 171         ty::ReLateBound(..) => false,
 172
 173         // These regions don't appear in types from type declarations:
 174         ty::ReErased | ty::ReVar(..) | ty::RePlaceholder(..) | ty::ReFree(..) => {
 175             bug!("unexpected region in outlives inference: {:?}", region);
 176         }
 177     }
 178 }