1 use crate::infer
::at
::At
;
2 use crate::infer
::canonical
::OriginalQueryValues
;
3 use crate::infer
::InferOk
;
5 use rustc_middle
::ty
::subst
::GenericArg
;
6 use rustc_middle
::ty
::{self, Ty, TyCtxt}
;
8 pub use rustc_middle
::traits
::query
::{DropckOutlivesResult, DtorckConstraint}
;
10 pub trait AtExt
<'tcx
> {
11 fn dropck_outlives(&self, ty
: Ty
<'tcx
>) -> InferOk
<'tcx
, Vec
<GenericArg
<'tcx
>>>;
14 impl<'cx
, 'tcx
> AtExt
<'tcx
> for At
<'cx
, 'tcx
> {
15 /// Given a type `ty` of some value being dropped, computes a set
16 /// of "kinds" (types, regions) that must be outlive the execution
17 /// of the destructor. These basically correspond to data that the
18 /// destructor might access. This is used during regionck to
19 /// impose "outlives" constraints on any lifetimes referenced
22 /// The rules here are given by the "dropck" RFCs, notably [#1238]
23 /// and [#1327]. This is a fixed-point computation, where we
24 /// explore all the data that will be dropped (transitively) when
25 /// a value of type `ty` is dropped. For each type T that will be
26 /// dropped and which has a destructor, we must assume that all
27 /// the types/regions of T are live during the destructor, unless
28 /// they are marked with a special attribute (`#[may_dangle]`).
30 /// [#1238]: https://github.com/rust-lang/rfcs/blob/master/text/1238-nonparametric-dropck.md
31 /// [#1327]: https://github.com/rust-lang/rfcs/blob/master/text/1327-dropck-param-eyepatch.md
32 fn dropck_outlives(&self, ty
: Ty
<'tcx
>) -> InferOk
<'tcx
, Vec
<GenericArg
<'tcx
>>> {
33 debug
!("dropck_outlives(ty={:?}, param_env={:?})", ty
, self.param_env
,);
35 // Quick check: there are a number of cases that we know do not require
37 let tcx
= self.infcx
.tcx
;
38 if trivial_dropck_outlives(tcx
, ty
) {
39 return InferOk { value: vec![], obligations: vec![] }
;
42 let mut orig_values
= OriginalQueryValues
::default();
43 let c_ty
= self.infcx
.canonicalize_query(&self.param_env
.and(ty
), &mut orig_values
);
44 let span
= self.cause
.span
;
45 debug
!("c_ty = {:?}", c_ty
);
46 if let Ok(result
) = &tcx
.dropck_outlives(c_ty
) {
47 if result
.is_proven() {
48 if let Ok(InferOk { value, obligations }
) =
49 self.infcx
.instantiate_query_response_and_region_obligations(
56 let ty
= self.infcx
.resolve_vars_if_possible(&ty
);
57 let kinds
= value
.into_kinds_reporting_overflows(tcx
, span
, ty
);
58 return InferOk { value: kinds, obligations }
;
63 // Errors and ambiuity in dropck occur in two cases:
64 // - unresolved inference variables at the end of typeck
65 // - non well-formed types where projections cannot be resolved
66 // Either of these should have created an error before.
67 tcx
.sess
.delay_span_bug(span
, "dtorck encountered internal error");
69 InferOk { value: vec![], obligations: vec![] }
73 /// This returns true if the type `ty` is "trivial" for
74 /// dropck-outlives -- that is, if it doesn't require any types to
75 /// outlive. This is similar but not *quite* the same as the
76 /// `needs_drop` test in the compiler already -- that is, for every
77 /// type T for which this function return true, needs-drop would
78 /// return `false`. But the reverse does not hold: in particular,
79 /// `needs_drop` returns false for `PhantomData`, but it is not
80 /// trivial for dropck-outlives.
82 /// Note also that `needs_drop` requires a "global" type (i.e., one
83 /// with erased regions), but this function does not.
84 pub fn trivial_dropck_outlives
<'tcx
>(tcx
: TyCtxt
<'tcx
>, ty
: Ty
<'tcx
>) -> bool
{
86 // None of these types have a destructor and hence they do not
87 // require anything in particular to outlive the dtor's
89 ty
::Infer(ty
::FreshIntTy(_
))
90 | ty
::Infer(ty
::FreshFloatTy(_
))
99 | ty
::GeneratorWitness(..)
106 // [T; N] and [T] have same properties as T.
107 ty
::Array(ty
, _
) | ty
::Slice(ty
) => trivial_dropck_outlives(tcx
, ty
),
109 // (T1..Tn) and closures have same properties as T1..Tn --
110 // check if *any* of those are trivial.
111 ty
::Tuple(ref tys
) => tys
.iter().all(|t
| trivial_dropck_outlives(tcx
, t
.expect_ty())),
112 ty
::Closure(_
, ref substs
) => {
113 substs
.as_closure().upvar_tys().all(|t
| trivial_dropck_outlives(tcx
, t
))
117 if Some(def
.did
) == tcx
.lang_items().manually_drop() {
118 // `ManuallyDrop` never has a dtor.
121 // Other types might. Moreover, PhantomData doesn't
122 // have a dtor, but it is considered to own its
123 // content, so it is non-trivial. Unions can have `impl Drop`,
124 // and hence are non-trivial as well.
129 // The following *might* require a destructor: needs deeper inspection.
134 | ty
::Placeholder(..)
137 | ty
::Generator(..) => false,
139 ty
::UnnormalizedProjection(..) => bug
!("only used with chalk-engine"),