]>
Commit | Line | Data |
---|---|---|
9fa01778 | 1 | use crate::infer::at::At; |
9fa01778 | 2 | use crate::infer::canonical::OriginalQueryValues; |
dfeec247 | 3 | use crate::infer::InferOk; |
74b04a01 | 4 | |
ba9703b0 XL |
5 | use rustc_middle::ty::subst::GenericArg; |
6 | use rustc_middle::ty::{self, Ty, TyCtxt}; | |
74b04a01 | 7 | |
ba9703b0 | 8 | pub use rustc_middle::traits::query::{DropckOutlivesResult, DtorckConstraint}; |
0531ce1d | 9 | |
ba9703b0 XL |
10 | pub trait AtExt<'tcx> { |
11 | fn dropck_outlives(&self, ty: Ty<'tcx>) -> InferOk<'tcx, Vec<GenericArg<'tcx>>>; | |
12 | } | |
13 | ||
14 | impl<'cx, 'tcx> AtExt<'tcx> for At<'cx, 'tcx> { | |
0531ce1d XL |
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 | |
20 | /// within. | |
21 | /// | |
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]`). | |
29 | /// | |
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 | |
ba9703b0 | 32 | fn dropck_outlives(&self, ty: Ty<'tcx>) -> InferOk<'tcx, Vec<GenericArg<'tcx>>> { |
dfeec247 | 33 | debug!("dropck_outlives(ty={:?}, param_env={:?})", ty, self.param_env,); |
0531ce1d XL |
34 | |
35 | // Quick check: there are a number of cases that we know do not require | |
36 | // any destructor. | |
37 | let tcx = self.infcx.tcx; | |
60c5eb7d | 38 | if trivial_dropck_outlives(tcx, ty) { |
dfeec247 | 39 | return InferOk { value: vec![], obligations: vec![] }; |
0531ce1d XL |
40 | } |
41 | ||
0bf4aa26 | 42 | let mut orig_values = OriginalQueryValues::default(); |
fc512014 | 43 | let c_ty = self.infcx.canonicalize_query(self.param_env.and(ty), &mut orig_values); |
0531ce1d XL |
44 | let span = self.cause.span; |
45 | debug!("c_ty = {:?}", c_ty); | |
fc512014 | 46 | if let Ok(result) = tcx.dropck_outlives(c_ty) { |
0731742a | 47 | if result.is_proven() { |
0bf4aa26 XL |
48 | if let Ok(InferOk { value, obligations }) = |
49 | self.infcx.instantiate_query_response_and_region_obligations( | |
dfeec247 XL |
50 | self.cause, |
51 | self.param_env, | |
52 | &orig_values, | |
53 | result, | |
54 | ) | |
0bf4aa26 | 55 | { |
fc512014 | 56 | let ty = self.infcx.resolve_vars_if_possible(ty); |
0bf4aa26 | 57 | let kinds = value.into_kinds_reporting_overflows(tcx, span, ty); |
dfeec247 | 58 | return InferOk { value: kinds, obligations }; |
0531ce1d XL |
59 | } |
60 | } | |
0531ce1d XL |
61 | } |
62 | ||
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 | |
b7449926 | 66 | // Either of these should have created an error before. |
dfeec247 | 67 | tcx.sess.delay_span_bug(span, "dtorck encountered internal error"); |
0731742a | 68 | |
dfeec247 | 69 | InferOk { value: vec![], obligations: vec![] } |
0531ce1d XL |
70 | } |
71 | } | |
72 | ||
0531ce1d XL |
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 | |
9fa01778 | 78 | /// return `false`. But the reverse does not hold: in particular, |
0531ce1d XL |
79 | /// `needs_drop` returns false for `PhantomData`, but it is not |
80 | /// trivial for dropck-outlives. | |
81 | /// | |
82 | /// Note also that `needs_drop` requires a "global" type (i.e., one | |
a1dfa0c6 | 83 | /// with erased regions), but this function does not. |
dc9dc135 | 84 | pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { |
1b1a35ee | 85 | match ty.kind() { |
0531ce1d XL |
86 | // None of these types have a destructor and hence they do not |
87 | // require anything in particular to outlive the dtor's | |
88 | // execution. | |
b7449926 XL |
89 | ty::Infer(ty::FreshIntTy(_)) |
90 | | ty::Infer(ty::FreshFloatTy(_)) | |
91 | | ty::Bool | |
92 | | ty::Int(_) | |
93 | | ty::Uint(_) | |
94 | | ty::Float(_) | |
95 | | ty::Never | |
96 | | ty::FnDef(..) | |
97 | | ty::FnPtr(_) | |
98 | | ty::Char | |
99 | | ty::GeneratorWitness(..) | |
100 | | ty::RawPtr(_) | |
101 | | ty::Ref(..) | |
102 | | ty::Str | |
103 | | ty::Foreign(..) | |
f035d41b | 104 | | ty::Error(_) => true, |
0531ce1d XL |
105 | |
106 | // [T; N] and [T] have same properties as T. | |
5099ac24 | 107 | ty::Array(ty, _) | ty::Slice(ty) => trivial_dropck_outlives(tcx, *ty), |
0531ce1d XL |
108 | |
109 | // (T1..Tn) and closures have same properties as T1..Tn -- | |
110 | // check if *any* of those are trivial. | |
60c5eb7d | 111 | ty::Tuple(ref tys) => tys.iter().all(|t| trivial_dropck_outlives(tcx, t.expect_ty())), |
ba9703b0 | 112 | ty::Closure(_, ref substs) => { |
29967ef6 | 113 | trivial_dropck_outlives(tcx, substs.as_closure().tupled_upvars_ty()) |
dfeec247 | 114 | } |
0531ce1d | 115 | |
b7449926 XL |
116 | ty::Adt(def, _) => { |
117 | if Some(def.did) == tcx.lang_items().manually_drop() { | |
8faf50e0 | 118 | // `ManuallyDrop` never has a dtor. |
0531ce1d XL |
119 | true |
120 | } else { | |
121 | // Other types might. Moreover, PhantomData doesn't | |
122 | // have a dtor, but it is considered to own its | |
b7449926 XL |
123 | // content, so it is non-trivial. Unions can have `impl Drop`, |
124 | // and hence are non-trivial as well. | |
0531ce1d XL |
125 | false |
126 | } | |
127 | } | |
128 | ||
0bf4aa26 | 129 | // The following *might* require a destructor: needs deeper inspection. |
b7449926 XL |
130 | ty::Dynamic(..) |
131 | | ty::Projection(..) | |
132 | | ty::Param(_) | |
133 | | ty::Opaque(..) | |
a1dfa0c6 | 134 | | ty::Placeholder(..) |
b7449926 | 135 | | ty::Infer(_) |
a1dfa0c6 | 136 | | ty::Bound(..) |
b7449926 | 137 | | ty::Generator(..) => false, |
0531ce1d XL |
138 | } |
139 | } |