]>
Commit | Line | Data |
---|---|---|
e9174d1e SL |
1 | // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT |
2 | // file at the top-level directory of this distribution and at | |
3 | // http://rust-lang.org/COPYRIGHT. | |
4 | // | |
5 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
6 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
7 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
8 | // option. This file may not be copied, modified, or distributed | |
9 | // except according to those terms. | |
10 | ||
11 | //! misc. type-system utilities too small to deserve their own file | |
12 | ||
abe05a73 | 13 | use hir::def::Def; |
ff7c6d11 | 14 | use hir::def_id::DefId; |
b7449926 XL |
15 | use hir::map::DefPathData; |
16 | use hir::{self, Node}; | |
ea8adc8c | 17 | use ich::NodeIdHashingMode; |
94b46f34 XL |
18 | use traits::{self, ObligationCause}; |
19 | use ty::{self, Ty, TyCtxt, GenericParamDefKind, TypeFoldable}; | |
20 | use ty::subst::{Substs, UnpackedKind}; | |
21 | use ty::query::TyCtxtAt; | |
b7449926 | 22 | use ty::TyKind::*; |
83c7162d | 23 | use ty::layout::{Integer, IntegerExt}; |
8bb4bdeb | 24 | use util::common::ErrorReported; |
476ff2be | 25 | use middle::lang_items; |
54a0048b | 26 | |
94b46f34 | 27 | use rustc_data_structures::stable_hasher::{StableHasher, HashStable}; |
041b39d2 | 28 | use rustc_data_structures::fx::FxHashMap; |
0531ce1d | 29 | use std::{cmp, fmt}; |
83c7162d | 30 | use syntax::ast; |
a7813a04 | 31 | use syntax::attr::{self, SignedInt, UnsignedInt}; |
8bb4bdeb | 32 | use syntax_pos::{Span, DUMMY_SP}; |
e9174d1e | 33 | |
0531ce1d XL |
34 | #[derive(Copy, Clone, Debug)] |
35 | pub struct Discr<'tcx> { | |
36 | /// bit representation of the discriminant, so `-128i8` is `0xFF_u128` | |
37 | pub val: u128, | |
38 | pub ty: Ty<'tcx> | |
39 | } | |
8bb4bdeb | 40 | |
0531ce1d XL |
41 | impl<'tcx> fmt::Display for Discr<'tcx> { |
42 | fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { | |
43 | match self.ty.sty { | |
b7449926 | 44 | ty::Int(ity) => { |
0531ce1d XL |
45 | let bits = ty::tls::with(|tcx| { |
46 | Integer::from_attr(tcx, SignedInt(ity)).size().bits() | |
47 | }); | |
48 | let x = self.val as i128; | |
49 | // sign extend the raw representation to be an i128 | |
50 | let x = (x << (128 - bits)) >> (128 - bits); | |
51 | write!(fmt, "{}", x) | |
52 | }, | |
53 | _ => write!(fmt, "{}", self.val), | |
54 | } | |
55 | } | |
cc61c64b | 56 | } |
8bb4bdeb | 57 | |
0531ce1d XL |
58 | impl<'tcx> Discr<'tcx> { |
59 | /// Adds 1 to the value and wraps around if the maximum for the type is reached | |
60 | pub fn wrap_incr<'a, 'gcx>(self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Self { | |
61 | self.checked_add(tcx, 1).0 | |
62 | } | |
63 | pub fn checked_add<'a, 'gcx>(self, tcx: TyCtxt<'a, 'gcx, 'tcx>, n: u128) -> (Self, bool) { | |
64 | let (int, signed) = match self.ty.sty { | |
b7449926 XL |
65 | Int(ity) => (Integer::from_attr(tcx, SignedInt(ity)), true), |
66 | Uint(uty) => (Integer::from_attr(tcx, UnsignedInt(uty)), false), | |
0531ce1d XL |
67 | _ => bug!("non integer discriminant"), |
68 | }; | |
8bb4bdeb | 69 | |
0531ce1d | 70 | let bit_size = int.size().bits(); |
94b46f34 | 71 | let shift = 128 - bit_size; |
0531ce1d XL |
72 | if signed { |
73 | let sext = |u| { | |
74 | let i = u as i128; | |
94b46f34 | 75 | (i << shift) >> shift |
0531ce1d XL |
76 | }; |
77 | let min = sext(1_u128 << (bit_size - 1)); | |
94b46f34 | 78 | let max = i128::max_value() >> shift; |
0531ce1d XL |
79 | let val = sext(self.val); |
80 | assert!(n < (i128::max_value() as u128)); | |
81 | let n = n as i128; | |
82 | let oflo = val > max - n; | |
83 | let val = if oflo { | |
84 | min + (n - (max - val) - 1) | |
85 | } else { | |
86 | val + n | |
87 | }; | |
88 | // zero the upper bits | |
89 | let val = val as u128; | |
94b46f34 | 90 | let val = (val << shift) >> shift; |
0531ce1d XL |
91 | (Self { |
92 | val: val as u128, | |
93 | ty: self.ty, | |
94 | }, oflo) | |
95 | } else { | |
94b46f34 | 96 | let max = u128::max_value() >> shift; |
0531ce1d XL |
97 | let val = self.val; |
98 | let oflo = val > max - n; | |
99 | let val = if oflo { | |
100 | n - (max - val) - 1 | |
101 | } else { | |
102 | val + n | |
103 | }; | |
104 | (Self { | |
105 | val: val, | |
106 | ty: self.ty, | |
107 | }, oflo) | |
8bb4bdeb XL |
108 | } |
109 | } | |
e9174d1e SL |
110 | } |
111 | ||
0531ce1d XL |
112 | pub trait IntTypeExt { |
113 | fn to_ty<'a, 'gcx, 'tcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx>; | |
114 | fn disr_incr<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, val: Option<Discr<'tcx>>) | |
115 | -> Option<Discr<'tcx>>; | |
116 | fn initial_discriminant<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Discr<'tcx>; | |
117 | } | |
118 | ||
e9174d1e | 119 | impl IntTypeExt for attr::IntType { |
8bb4bdeb | 120 | fn to_ty<'a, 'gcx, 'tcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> { |
e9174d1e | 121 | match *self { |
a7813a04 XL |
122 | SignedInt(ast::IntTy::I8) => tcx.types.i8, |
123 | SignedInt(ast::IntTy::I16) => tcx.types.i16, | |
124 | SignedInt(ast::IntTy::I32) => tcx.types.i32, | |
125 | SignedInt(ast::IntTy::I64) => tcx.types.i64, | |
32a655c1 | 126 | SignedInt(ast::IntTy::I128) => tcx.types.i128, |
2c00a5a8 | 127 | SignedInt(ast::IntTy::Isize) => tcx.types.isize, |
a7813a04 XL |
128 | UnsignedInt(ast::UintTy::U8) => tcx.types.u8, |
129 | UnsignedInt(ast::UintTy::U16) => tcx.types.u16, | |
130 | UnsignedInt(ast::UintTy::U32) => tcx.types.u32, | |
131 | UnsignedInt(ast::UintTy::U64) => tcx.types.u64, | |
32a655c1 | 132 | UnsignedInt(ast::UintTy::U128) => tcx.types.u128, |
2c00a5a8 | 133 | UnsignedInt(ast::UintTy::Usize) => tcx.types.usize, |
e9174d1e SL |
134 | } |
135 | } | |
136 | ||
0531ce1d XL |
137 | fn initial_discriminant<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Discr<'tcx> { |
138 | Discr { | |
139 | val: 0, | |
140 | ty: self.to_ty(tcx) | |
e9174d1e SL |
141 | } |
142 | } | |
143 | ||
0531ce1d XL |
144 | fn disr_incr<'a, 'tcx>( |
145 | &self, | |
146 | tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
147 | val: Option<Discr<'tcx>>, | |
148 | ) -> Option<Discr<'tcx>> { | |
a7813a04 | 149 | if let Some(val) = val { |
0531ce1d XL |
150 | assert_eq!(self.to_ty(tcx), val.ty); |
151 | let (new, oflo) = val.checked_add(tcx, 1); | |
152 | if oflo { | |
153 | None | |
154 | } else { | |
155 | Some(new) | |
156 | } | |
a7813a04 XL |
157 | } else { |
158 | Some(self.initial_discriminant(tcx)) | |
159 | } | |
e9174d1e SL |
160 | } |
161 | } | |
162 | ||
163 | ||
94b46f34 | 164 | #[derive(Clone)] |
32a655c1 | 165 | pub enum CopyImplementationError<'tcx> { |
94b46f34 | 166 | InfrigingFields(Vec<&'tcx ty::FieldDef>), |
e9174d1e | 167 | NotAnAdt, |
cc61c64b | 168 | HasDestructor, |
e9174d1e SL |
169 | } |
170 | ||
171 | /// Describes whether a type is representable. For types that are not | |
172 | /// representable, 'SelfRecursive' and 'ContainsRecursive' are used to | |
173 | /// distinguish between types that are recursive with themselves and types that | |
174 | /// contain a different recursive type. These cases can therefore be treated | |
175 | /// differently when reporting errors. | |
176 | /// | |
177 | /// The ordering of the cases is significant. They are sorted so that cmp::max | |
178 | /// will keep the "more erroneous" of two values. | |
7cac9316 | 179 | #[derive(Clone, PartialOrd, Ord, Eq, PartialEq, Debug)] |
e9174d1e SL |
180 | pub enum Representability { |
181 | Representable, | |
182 | ContainsRecursive, | |
7cac9316 | 183 | SelfRecursive(Vec<Span>), |
e9174d1e SL |
184 | } |
185 | ||
7cac9316 | 186 | impl<'tcx> ty::ParamEnv<'tcx> { |
7cac9316 XL |
187 | pub fn can_type_implement_copy<'a>(self, |
188 | tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
94b46f34 | 189 | self_type: Ty<'tcx>) |
7cac9316 | 190 | -> Result<(), CopyImplementationError<'tcx>> { |
e9174d1e | 191 | // FIXME: (@jroesch) float this code up |
041b39d2 | 192 | tcx.infer_ctxt().enter(|infcx| { |
32a655c1 | 193 | let (adt, substs) = match self_type.sty { |
83c7162d XL |
194 | // These types used to have a builtin impl. |
195 | // Now libcore provides that impl. | |
b7449926 XL |
196 | ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Float(_) | |
197 | ty::Char | ty::RawPtr(..) | ty::Never | | |
198 | ty::Ref(_, _, hir::MutImmutable) => return Ok(()), | |
83c7162d | 199 | |
b7449926 | 200 | ty::Adt(adt, substs) => (adt, substs), |
83c7162d | 201 | |
cc61c64b | 202 | _ => return Err(CopyImplementationError::NotAnAdt), |
a7813a04 | 203 | }; |
e9174d1e | 204 | |
94b46f34 | 205 | let mut infringing = Vec::new(); |
32a655c1 SL |
206 | for variant in &adt.variants { |
207 | for field in &variant.fields { | |
94b46f34 XL |
208 | let span = tcx.def_span(field.did); |
209 | let ty = field.ty(tcx, substs); | |
210 | if ty.references_error() { | |
211 | continue; | |
32a655c1 | 212 | } |
94b46f34 XL |
213 | let cause = ObligationCause { span, ..ObligationCause::dummy() }; |
214 | let ctx = traits::FulfillmentContext::new(); | |
215 | match traits::fully_normalize(&infcx, ctx, cause, self, &ty) { | |
216 | Ok(ty) => if infcx.type_moves_by_default(self, ty, span) { | |
217 | infringing.push(field); | |
218 | } | |
219 | Err(errors) => { | |
220 | infcx.report_fulfillment_errors(&errors, None, false); | |
221 | } | |
222 | }; | |
32a655c1 SL |
223 | } |
224 | } | |
94b46f34 XL |
225 | if !infringing.is_empty() { |
226 | return Err(CopyImplementationError::InfrigingFields(infringing)); | |
227 | } | |
8bb4bdeb | 228 | if adt.has_dtor(tcx) { |
a7813a04 XL |
229 | return Err(CopyImplementationError::HasDestructor); |
230 | } | |
e9174d1e | 231 | |
a7813a04 XL |
232 | Ok(()) |
233 | }) | |
e9174d1e SL |
234 | } |
235 | } | |
236 | ||
cc61c64b XL |
237 | impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> { |
238 | /// Creates a hash of the type `Ty` which will be the same no matter what crate | |
239 | /// context it's calculated within. This is used by the `type_id` intrinsic. | |
240 | pub fn type_id_hash(self, ty: Ty<'tcx>) -> u64 { | |
241 | let mut hasher = StableHasher::new(); | |
ea8adc8c | 242 | let mut hcx = self.create_stable_hashing_context(); |
cc61c64b | 243 | |
3b2f2976 XL |
244 | // We want the type_id be independent of the types free regions, so we |
245 | // erase them. The erase_regions() call will also anonymize bound | |
246 | // regions, which is desirable too. | |
247 | let ty = self.erase_regions(&ty); | |
248 | ||
cc61c64b XL |
249 | hcx.while_hashing_spans(false, |hcx| { |
250 | hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| { | |
251 | ty.hash_stable(hcx, &mut hasher); | |
252 | }); | |
253 | }); | |
254 | hasher.finish() | |
255 | } | |
256 | } | |
257 | ||
a7813a04 | 258 | impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { |
5bcae85e SL |
259 | pub fn has_error_field(self, ty: Ty<'tcx>) -> bool { |
260 | match ty.sty { | |
b7449926 | 261 | ty::Adt(def, substs) => { |
5bcae85e SL |
262 | for field in def.all_fields() { |
263 | let field_ty = field.ty(self, substs); | |
b7449926 | 264 | if let Error = field_ty.sty { |
5bcae85e SL |
265 | return true; |
266 | } | |
267 | } | |
268 | } | |
cc61c64b | 269 | _ => (), |
5bcae85e SL |
270 | } |
271 | false | |
272 | } | |
273 | ||
e9174d1e SL |
274 | /// Returns the deeply last field of nested structures, or the same type, |
275 | /// if not a structure at all. Corresponds to the only possible unsized | |
276 | /// field, and its type can be used to determine unsizing strategy. | |
a7813a04 | 277 | pub fn struct_tail(self, mut ty: Ty<'tcx>) -> Ty<'tcx> { |
7cac9316 XL |
278 | loop { |
279 | match ty.sty { | |
b7449926 | 280 | ty::Adt(def, substs) => { |
7cac9316 XL |
281 | if !def.is_struct() { |
282 | break; | |
283 | } | |
2c00a5a8 | 284 | match def.non_enum_variant().fields.last() { |
7cac9316 XL |
285 | Some(f) => ty = f.ty(self, substs), |
286 | None => break, | |
287 | } | |
288 | } | |
289 | ||
b7449926 | 290 | ty::Tuple(tys) => { |
7cac9316 XL |
291 | if let Some((&last_ty, _)) = tys.split_last() { |
292 | ty = last_ty; | |
293 | } else { | |
294 | break; | |
295 | } | |
296 | } | |
297 | ||
298 | _ => { | |
299 | break; | |
300 | } | |
e9174d1e SL |
301 | } |
302 | } | |
303 | ty | |
304 | } | |
305 | ||
306 | /// Same as applying struct_tail on `source` and `target`, but only | |
307 | /// keeps going as long as the two types are instances of the same | |
308 | /// structure definitions. | |
309 | /// For `(Foo<Foo<T>>, Foo<Trait>)`, the result will be `(Foo<T>, Trait)`, | |
310 | /// whereas struct_tail produces `T`, and `Trait`, respectively. | |
a7813a04 | 311 | pub fn struct_lockstep_tails(self, |
e9174d1e SL |
312 | source: Ty<'tcx>, |
313 | target: Ty<'tcx>) | |
314 | -> (Ty<'tcx>, Ty<'tcx>) { | |
315 | let (mut a, mut b) = (source, target); | |
041b39d2 XL |
316 | loop { |
317 | match (&a.sty, &b.sty) { | |
b7449926 | 318 | (&Adt(a_def, a_substs), &Adt(b_def, b_substs)) |
041b39d2 | 319 | if a_def == b_def && a_def.is_struct() => { |
2c00a5a8 | 320 | if let Some(f) = a_def.non_enum_variant().fields.last() { |
041b39d2 XL |
321 | a = f.ty(self, a_substs); |
322 | b = f.ty(self, b_substs); | |
323 | } else { | |
324 | break; | |
325 | } | |
326 | }, | |
b7449926 | 327 | (&Tuple(a_tys), &Tuple(b_tys)) |
041b39d2 XL |
328 | if a_tys.len() == b_tys.len() => { |
329 | if let Some(a_last) = a_tys.last() { | |
330 | a = a_last; | |
331 | b = b_tys.last().unwrap(); | |
332 | } else { | |
333 | break; | |
334 | } | |
335 | }, | |
cc61c64b | 336 | _ => break, |
e9174d1e SL |
337 | } |
338 | } | |
339 | (a, b) | |
340 | } | |
341 | ||
e9174d1e SL |
342 | /// Given a set of predicates that apply to an object type, returns |
343 | /// the region bounds that the (erased) `Self` type must | |
344 | /// outlive. Precisely *because* the `Self` type is erased, the | |
345 | /// parameter `erased_self_ty` must be supplied to indicate what type | |
346 | /// has been used to represent `Self` in the predicates | |
347 | /// themselves. This should really be a unique type; `FreshTy(0)` is a | |
348 | /// popular choice. | |
349 | /// | |
350 | /// NB: in some cases, particularly around higher-ranked bounds, | |
351 | /// this function returns a kind of conservative approximation. | |
352 | /// That is, all regions returned by this function are definitely | |
353 | /// required, but there may be other region bounds that are not | |
354 | /// returned, as well as requirements like `for<'a> T: 'a`. | |
355 | /// | |
356 | /// Requires that trait definitions have been processed so that we can | |
357 | /// elaborate predicates and walk supertraits. | |
7cac9316 XL |
358 | /// |
359 | /// FIXME callers may only have a &[Predicate], not a Vec, so that's | |
360 | /// what this code should accept. | |
a7813a04 | 361 | pub fn required_region_bounds(self, |
e9174d1e SL |
362 | erased_self_ty: Ty<'tcx>, |
363 | predicates: Vec<ty::Predicate<'tcx>>) | |
7cac9316 | 364 | -> Vec<ty::Region<'tcx>> { |
e9174d1e SL |
365 | debug!("required_region_bounds(erased_self_ty={:?}, predicates={:?})", |
366 | erased_self_ty, | |
367 | predicates); | |
368 | ||
369 | assert!(!erased_self_ty.has_escaping_regions()); | |
370 | ||
371 | traits::elaborate_predicates(self, predicates) | |
372 | .filter_map(|predicate| { | |
373 | match predicate { | |
374 | ty::Predicate::Projection(..) | | |
375 | ty::Predicate::Trait(..) | | |
cc61c64b | 376 | ty::Predicate::Subtype(..) | |
e9174d1e SL |
377 | ty::Predicate::WellFormed(..) | |
378 | ty::Predicate::ObjectSafe(..) | | |
a7813a04 | 379 | ty::Predicate::ClosureKind(..) | |
ea8adc8c XL |
380 | ty::Predicate::RegionOutlives(..) | |
381 | ty::Predicate::ConstEvaluatable(..) => { | |
e9174d1e SL |
382 | None |
383 | } | |
83c7162d | 384 | ty::Predicate::TypeOutlives(predicate) => { |
e9174d1e SL |
385 | // Search for a bound of the form `erased_self_ty |
386 | // : 'a`, but be wary of something like `for<'a> | |
387 | // erased_self_ty : 'a` (we interpret a | |
388 | // higher-ranked bound like that as 'static, | |
389 | // though at present the code in `fulfill.rs` | |
390 | // considers such bounds to be unsatisfiable, so | |
391 | // it's kind of a moot point since you could never | |
392 | // construct such an object, but this seems | |
393 | // correct even if that code changes). | |
83c7162d XL |
394 | let ty::OutlivesPredicate(ref t, ref r) = predicate.skip_binder(); |
395 | if t == &erased_self_ty && !r.has_escaping_regions() { | |
396 | Some(*r) | |
e9174d1e SL |
397 | } else { |
398 | None | |
399 | } | |
400 | } | |
401 | } | |
402 | }) | |
403 | .collect() | |
404 | } | |
405 | ||
8bb4bdeb XL |
406 | /// Calculate the destructor of a given type. |
407 | pub fn calculate_dtor( | |
408 | self, | |
409 | adt_did: DefId, | |
0531ce1d | 410 | validate: &mut dyn FnMut(Self, DefId) -> Result<(), ErrorReported> |
8bb4bdeb | 411 | ) -> Option<ty::Destructor> { |
ea8adc8c | 412 | let drop_trait = if let Some(def_id) = self.lang_items().drop_trait() { |
8bb4bdeb XL |
413 | def_id |
414 | } else { | |
415 | return None; | |
416 | }; | |
417 | ||
94b46f34 | 418 | ty::query::queries::coherent_trait::ensure(self, drop_trait); |
8bb4bdeb XL |
419 | |
420 | let mut dtor_did = None; | |
7cac9316 | 421 | let ty = self.type_of(adt_did); |
041b39d2 | 422 | self.for_each_relevant_impl(drop_trait, ty, |impl_did| { |
8bb4bdeb XL |
423 | if let Some(item) = self.associated_items(impl_did).next() { |
424 | if let Ok(()) = validate(self, impl_did) { | |
425 | dtor_did = Some(item.def_id); | |
426 | } | |
427 | } | |
428 | }); | |
429 | ||
ff7c6d11 | 430 | Some(ty::Destructor { did: dtor_did? }) |
cc61c64b XL |
431 | } |
432 | ||
433 | /// Return the set of types that are required to be alive in | |
434 | /// order to run the destructor of `def` (see RFCs 769 and | |
435 | /// 1238). | |
436 | /// | |
437 | /// Note that this returns only the constraints for the | |
438 | /// destructor of `def` itself. For the destructors of the | |
439 | /// contents, you need `adt_dtorck_constraint`. | |
440 | pub fn destructor_constraints(self, def: &'tcx ty::AdtDef) | |
441 | -> Vec<ty::subst::Kind<'tcx>> | |
442 | { | |
443 | let dtor = match def.destructor(self) { | |
444 | None => { | |
445 | debug!("destructor_constraints({:?}) - no dtor", def.did); | |
446 | return vec![] | |
447 | } | |
448 | Some(dtor) => dtor.did | |
e9174d1e | 449 | }; |
b039eaaf SL |
450 | |
451 | // RFC 1238: if the destructor method is tagged with the | |
452 | // attribute `unsafe_destructor_blind_to_params`, then the | |
453 | // compiler is being instructed to *assume* that the | |
454 | // destructor will not access borrowed data, | |
455 | // even if such data is otherwise reachable. | |
e9174d1e | 456 | // |
b039eaaf SL |
457 | // Such access can be in plain sight (e.g. dereferencing |
458 | // `*foo.0` of `Foo<'a>(&'a u32)`) or indirectly hidden | |
459 | // (e.g. calling `foo.0.clone()` of `Foo<T:Clone>`). | |
cc61c64b XL |
460 | if self.has_attr(dtor, "unsafe_destructor_blind_to_params") { |
461 | debug!("destructor_constraint({:?}) - blind", def.did); | |
462 | return vec![]; | |
463 | } | |
464 | ||
465 | let impl_def_id = self.associated_item(dtor).container.id(); | |
7cac9316 | 466 | let impl_generics = self.generics_of(impl_def_id); |
cc61c64b XL |
467 | |
468 | // We have a destructor - all the parameters that are not | |
469 | // pure_wrt_drop (i.e, don't have a #[may_dangle] attribute) | |
470 | // must be live. | |
471 | ||
472 | // We need to return the list of parameters from the ADTs | |
473 | // generics/substs that correspond to impure parameters on the | |
474 | // impl's generics. This is a bit ugly, but conceptually simple: | |
475 | // | |
476 | // Suppose our ADT looks like the following | |
477 | // | |
478 | // struct S<X, Y, Z>(X, Y, Z); | |
479 | // | |
480 | // and the impl is | |
481 | // | |
482 | // impl<#[may_dangle] P0, P1, P2> Drop for S<P1, P2, P0> | |
483 | // | |
484 | // We want to return the parameters (X, Y). For that, we match | |
485 | // up the item-substs <X, Y, Z> with the substs on the impl ADT, | |
486 | // <P1, P2, P0>, and then look up which of the impl substs refer to | |
487 | // parameters marked as pure. | |
488 | ||
7cac9316 | 489 | let impl_substs = match self.type_of(impl_def_id).sty { |
b7449926 | 490 | ty::Adt(def_, substs) if def_ == def => substs, |
cc61c64b XL |
491 | _ => bug!() |
492 | }; | |
493 | ||
7cac9316 | 494 | let item_substs = match self.type_of(def.did).sty { |
b7449926 | 495 | ty::Adt(def_, substs) if def_ == def => substs, |
cc61c64b XL |
496 | _ => bug!() |
497 | }; | |
498 | ||
499 | let result = item_substs.iter().zip(impl_substs.iter()) | |
500 | .filter(|&(_, &k)| { | |
0531ce1d XL |
501 | match k.unpack() { |
502 | UnpackedKind::Lifetime(&ty::RegionKind::ReEarlyBound(ref ebr)) => { | |
503 | !impl_generics.region_param(ebr, self).pure_wrt_drop | |
504 | } | |
505 | UnpackedKind::Type(&ty::TyS { | |
b7449926 | 506 | sty: ty::Param(ref pt), .. |
0531ce1d XL |
507 | }) => { |
508 | !impl_generics.type_param(pt, self).pure_wrt_drop | |
509 | } | |
510 | UnpackedKind::Lifetime(_) | UnpackedKind::Type(_) => { | |
511 | // not a type or region param - this should be reported | |
512 | // as an error. | |
513 | false | |
514 | } | |
cc61c64b XL |
515 | } |
516 | }).map(|(&item_param, _)| item_param).collect(); | |
517 | debug!("destructor_constraint({:?}) = {:?}", def.did, result); | |
518 | result | |
b039eaaf | 519 | } |
9e0c209e | 520 | |
8faf50e0 XL |
521 | /// True if `def_id` refers to a closure (e.g., `|x| x * 2`). Note |
522 | /// that closures have a def-id, but the closure *expression* also | |
523 | /// has a `HirId` that is located within the context where the | |
524 | /// closure appears (and, sadly, a corresponding `NodeId`, since | |
525 | /// those are not yet phased out). The parent of the closure's | |
526 | /// def-id will also be the context where it appears. | |
abe05a73 XL |
527 | pub fn is_closure(self, def_id: DefId) -> bool { |
528 | self.def_key(def_id).disambiguated_data.data == DefPathData::ClosureExpr | |
529 | } | |
530 | ||
8faf50e0 XL |
531 | /// True if `def_id` refers to a trait (e.g., `trait Foo { ... }`). |
532 | pub fn is_trait(self, def_id: DefId) -> bool { | |
533 | if let DefPathData::Trait(_) = self.def_key(def_id).disambiguated_data.data { | |
534 | true | |
535 | } else { | |
536 | false | |
537 | } | |
538 | } | |
539 | ||
540 | /// True if this def-id refers to the implicit constructor for | |
541 | /// a tuple struct like `struct Foo(u32)`. | |
542 | pub fn is_struct_constructor(self, def_id: DefId) -> bool { | |
543 | self.def_key(def_id).disambiguated_data.data == DefPathData::StructCtor | |
544 | } | |
545 | ||
ff7c6d11 XL |
546 | /// Given the `DefId` of a fn or closure, returns the `DefId` of |
547 | /// the innermost fn item that the closure is contained within. | |
548 | /// This is a significant def-id because, when we do | |
549 | /// type-checking, we type-check this fn item and all of its | |
550 | /// (transitive) closures together. Therefore, when we fetch the | |
551 | /// `typeck_tables_of` the closure, for example, we really wind up | |
552 | /// fetching the `typeck_tables_of` the enclosing fn item. | |
cc61c64b | 553 | pub fn closure_base_def_id(self, def_id: DefId) -> DefId { |
476ff2be | 554 | let mut def_id = def_id; |
abe05a73 | 555 | while self.is_closure(def_id) { |
476ff2be SL |
556 | def_id = self.parent_def_id(def_id).unwrap_or_else(|| { |
557 | bug!("closure {:?} has no parent", def_id); | |
558 | }); | |
559 | } | |
560 | def_id | |
9e0c209e | 561 | } |
cc61c64b | 562 | |
ff7c6d11 XL |
563 | /// Given the def-id and substs a closure, creates the type of |
564 | /// `self` argument that the closure expects. For example, for a | |
565 | /// `Fn` closure, this would return a reference type `&T` where | |
566 | /// `T=closure_ty`. | |
567 | /// | |
568 | /// Returns `None` if this closure's kind has not yet been inferred. | |
569 | /// This should only be possible during type checking. | |
570 | /// | |
571 | /// Note that the return value is a late-bound region and hence | |
572 | /// wrapped in a binder. | |
573 | pub fn closure_env_ty(self, | |
574 | closure_def_id: DefId, | |
575 | closure_substs: ty::ClosureSubsts<'tcx>) | |
576 | -> Option<ty::Binder<Ty<'tcx>>> | |
577 | { | |
578 | let closure_ty = self.mk_closure(closure_def_id, closure_substs); | |
94b46f34 | 579 | let env_region = ty::ReLateBound(ty::INNERMOST, ty::BrEnv); |
ff7c6d11 XL |
580 | let closure_kind_ty = closure_substs.closure_kind_ty(closure_def_id, self); |
581 | let closure_kind = closure_kind_ty.to_opt_closure_kind()?; | |
582 | let env_ty = match closure_kind { | |
583 | ty::ClosureKind::Fn => self.mk_imm_ref(self.mk_region(env_region), closure_ty), | |
584 | ty::ClosureKind::FnMut => self.mk_mut_ref(self.mk_region(env_region), closure_ty), | |
585 | ty::ClosureKind::FnOnce => closure_ty, | |
586 | }; | |
83c7162d | 587 | Some(ty::Binder::bind(env_ty)) |
ff7c6d11 XL |
588 | } |
589 | ||
cc61c64b XL |
590 | /// Given the def-id of some item that has no type parameters, make |
591 | /// a suitable "empty substs" for it. | |
94b46f34 XL |
592 | pub fn empty_substs_for_def_id(self, item_def_id: DefId) -> &'tcx Substs<'tcx> { |
593 | Substs::for_item(self, item_def_id, |param, _| { | |
594 | match param.kind { | |
595 | GenericParamDefKind::Lifetime => self.types.re_erased.into(), | |
596 | GenericParamDefKind::Type {..} => { | |
597 | bug!("empty_substs_for_def_id: {:?} has type parameters", item_def_id) | |
598 | } | |
599 | } | |
cc61c64b XL |
600 | }) |
601 | } | |
7cac9316 | 602 | |
0531ce1d XL |
603 | /// Return whether the node pointed to by def_id is a static item, and its mutability |
604 | pub fn is_static(&self, def_id: DefId) -> Option<hir::Mutability> { | |
abe05a73 XL |
605 | if let Some(node) = self.hir.get_if_local(def_id) { |
606 | match node { | |
b7449926 | 607 | Node::Item(&hir::Item { |
8faf50e0 | 608 | node: hir::ItemKind::Static(_, mutbl, _), .. |
0531ce1d | 609 | }) => Some(mutbl), |
b7449926 | 610 | Node::ForeignItem(&hir::ForeignItem { |
8faf50e0 | 611 | node: hir::ForeignItemKind::Static(_, is_mutbl), .. |
0531ce1d XL |
612 | }) => |
613 | Some(if is_mutbl { | |
614 | hir::Mutability::MutMutable | |
615 | } else { | |
616 | hir::Mutability::MutImmutable | |
617 | }), | |
618 | _ => None | |
abe05a73 XL |
619 | } |
620 | } else { | |
621 | match self.describe_def(def_id) { | |
0531ce1d XL |
622 | Some(Def::Static(_, is_mutbl)) => |
623 | Some(if is_mutbl { | |
624 | hir::Mutability::MutMutable | |
625 | } else { | |
626 | hir::Mutability::MutImmutable | |
627 | }), | |
628 | _ => None | |
abe05a73 XL |
629 | } |
630 | } | |
631 | } | |
9e0c209e SL |
632 | } |
633 | ||
a7813a04 | 634 | impl<'a, 'tcx> ty::TyS<'tcx> { |
7cac9316 XL |
635 | pub fn moves_by_default(&'tcx self, |
636 | tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
637 | param_env: ty::ParamEnv<'tcx>, | |
638 | span: Span) | |
639 | -> bool { | |
640 | !tcx.at(span).is_copy_raw(param_env.and(self)) | |
e9174d1e SL |
641 | } |
642 | ||
7cac9316 | 643 | pub fn is_sized(&'tcx self, |
0531ce1d XL |
644 | tcx_at: TyCtxtAt<'a, 'tcx, 'tcx>, |
645 | param_env: ty::ParamEnv<'tcx>)-> bool | |
e9174d1e | 646 | { |
0531ce1d | 647 | tcx_at.is_sized_raw(param_env.and(self)) |
e9174d1e SL |
648 | } |
649 | ||
7cac9316 XL |
650 | pub fn is_freeze(&'tcx self, |
651 | tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
652 | param_env: ty::ParamEnv<'tcx>, | |
653 | span: Span)-> bool | |
cc61c64b | 654 | { |
7cac9316 | 655 | tcx.at(span).is_freeze_raw(param_env.and(self)) |
cc61c64b XL |
656 | } |
657 | ||
658 | /// If `ty.needs_drop(...)` returns `true`, then `ty` is definitely | |
659 | /// non-copy and *might* have a destructor attached; if it returns | |
660 | /// `false`, then `ty` definitely has no destructor (i.e. no drop glue). | |
661 | /// | |
662 | /// (Note that this implies that if `ty` has a destructor attached, | |
663 | /// then `needs_drop` will definitely return `true` for `ty`.) | |
664 | #[inline] | |
7cac9316 XL |
665 | pub fn needs_drop(&'tcx self, |
666 | tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
667 | param_env: ty::ParamEnv<'tcx>) | |
668 | -> bool { | |
669 | tcx.needs_drop_raw(param_env.and(self)) | |
cc61c64b XL |
670 | } |
671 | ||
e9174d1e SL |
672 | /// Check whether a type is representable. This means it cannot contain unboxed |
673 | /// structural recursion. This check is needed for structs and enums. | |
7cac9316 XL |
674 | pub fn is_representable(&'tcx self, |
675 | tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
676 | sp: Span) | |
a7813a04 | 677 | -> Representability { |
e9174d1e SL |
678 | |
679 | // Iterate until something non-representable is found | |
7cac9316 XL |
680 | fn fold_repr<It: Iterator<Item=Representability>>(iter: It) -> Representability { |
681 | iter.fold(Representability::Representable, |r1, r2| { | |
682 | match (r1, r2) { | |
683 | (Representability::SelfRecursive(v1), | |
684 | Representability::SelfRecursive(v2)) => { | |
685 | Representability::SelfRecursive(v1.iter().map(|s| *s).chain(v2).collect()) | |
686 | } | |
687 | (r1, r2) => cmp::max(r1, r2) | |
688 | } | |
689 | }) | |
e9174d1e SL |
690 | } |
691 | ||
041b39d2 XL |
692 | fn are_inner_types_recursive<'a, 'tcx>( |
693 | tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, | |
694 | seen: &mut Vec<Ty<'tcx>>, | |
695 | representable_cache: &mut FxHashMap<Ty<'tcx>, Representability>, | |
696 | ty: Ty<'tcx>) | |
697 | -> Representability | |
698 | { | |
e9174d1e | 699 | match ty.sty { |
b7449926 | 700 | Tuple(ref ts) => { |
7cac9316 XL |
701 | // Find non representable |
702 | fold_repr(ts.iter().map(|ty| { | |
041b39d2 | 703 | is_type_structurally_recursive(tcx, sp, seen, representable_cache, ty) |
7cac9316 | 704 | })) |
e9174d1e SL |
705 | } |
706 | // Fixed-length vectors. | |
707 | // FIXME(#11924) Behavior undecided for zero-length vectors. | |
b7449926 | 708 | Array(ty, _) => { |
041b39d2 | 709 | is_type_structurally_recursive(tcx, sp, seen, representable_cache, ty) |
e9174d1e | 710 | } |
b7449926 | 711 | Adt(def, substs) => { |
7cac9316 XL |
712 | // Find non representable fields with their spans |
713 | fold_repr(def.all_fields().map(|field| { | |
714 | let ty = field.ty(tcx, substs); | |
715 | let span = tcx.hir.span_if_local(field.did).unwrap_or(sp); | |
041b39d2 XL |
716 | match is_type_structurally_recursive(tcx, span, seen, |
717 | representable_cache, ty) | |
718 | { | |
7cac9316 XL |
719 | Representability::SelfRecursive(_) => { |
720 | Representability::SelfRecursive(vec![span]) | |
721 | } | |
722 | x => x, | |
723 | } | |
724 | })) | |
e9174d1e | 725 | } |
b7449926 | 726 | Closure(..) => { |
e9174d1e SL |
727 | // this check is run on type definitions, so we don't expect |
728 | // to see closure types | |
54a0048b | 729 | bug!("requires check invoked on inapplicable type: {:?}", ty) |
e9174d1e SL |
730 | } |
731 | _ => Representability::Representable, | |
732 | } | |
733 | } | |
734 | ||
476ff2be | 735 | fn same_struct_or_enum<'tcx>(ty: Ty<'tcx>, def: &'tcx ty::AdtDef) -> bool { |
e9174d1e | 736 | match ty.sty { |
b7449926 | 737 | Adt(ty_def, _) => { |
e9174d1e SL |
738 | ty_def == def |
739 | } | |
740 | _ => false | |
741 | } | |
742 | } | |
743 | ||
744 | fn same_type<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool { | |
745 | match (&a.sty, &b.sty) { | |
b7449926 | 746 | (&Adt(did_a, substs_a), &Adt(did_b, substs_b)) => { |
e9174d1e SL |
747 | if did_a != did_b { |
748 | return false; | |
749 | } | |
750 | ||
9e0c209e | 751 | substs_a.types().zip(substs_b.types()).all(|(a, b)| same_type(a, b)) |
e9174d1e | 752 | } |
cc61c64b | 753 | _ => a == b, |
e9174d1e SL |
754 | } |
755 | } | |
756 | ||
757 | // Does the type `ty` directly (without indirection through a pointer) | |
758 | // contain any types on stack `seen`? | |
041b39d2 XL |
759 | fn is_type_structurally_recursive<'a, 'tcx>( |
760 | tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
761 | sp: Span, | |
762 | seen: &mut Vec<Ty<'tcx>>, | |
763 | representable_cache: &mut FxHashMap<Ty<'tcx>, Representability>, | |
764 | ty: Ty<'tcx>) -> Representability | |
765 | { | |
7cac9316 | 766 | debug!("is_type_structurally_recursive: {:?} {:?}", ty, sp); |
041b39d2 XL |
767 | if let Some(representability) = representable_cache.get(ty) { |
768 | debug!("is_type_structurally_recursive: {:?} {:?} - (cached) {:?}", | |
769 | ty, sp, representability); | |
770 | return representability.clone(); | |
771 | } | |
772 | ||
773 | let representability = is_type_structurally_recursive_inner( | |
774 | tcx, sp, seen, representable_cache, ty); | |
775 | ||
776 | representable_cache.insert(ty, representability.clone()); | |
777 | representability | |
778 | } | |
e9174d1e | 779 | |
041b39d2 XL |
780 | fn is_type_structurally_recursive_inner<'a, 'tcx>( |
781 | tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
782 | sp: Span, | |
783 | seen: &mut Vec<Ty<'tcx>>, | |
784 | representable_cache: &mut FxHashMap<Ty<'tcx>, Representability>, | |
785 | ty: Ty<'tcx>) -> Representability | |
786 | { | |
e9174d1e | 787 | match ty.sty { |
b7449926 | 788 | Adt(def, _) => { |
e9174d1e SL |
789 | { |
790 | // Iterate through stack of previously seen types. | |
791 | let mut iter = seen.iter(); | |
792 | ||
793 | // The first item in `seen` is the type we are actually curious about. | |
794 | // We want to return SelfRecursive if this type contains itself. | |
795 | // It is important that we DON'T take generic parameters into account | |
796 | // for this check, so that Bar<T> in this example counts as SelfRecursive: | |
797 | // | |
798 | // struct Foo; | |
799 | // struct Bar<T> { x: Bar<Foo> } | |
800 | ||
3157f602 XL |
801 | if let Some(&seen_type) = iter.next() { |
802 | if same_struct_or_enum(seen_type, def) { | |
803 | debug!("SelfRecursive: {:?} contains {:?}", | |
804 | seen_type, | |
805 | ty); | |
7cac9316 | 806 | return Representability::SelfRecursive(vec![sp]); |
e9174d1e | 807 | } |
e9174d1e SL |
808 | } |
809 | ||
810 | // We also need to know whether the first item contains other types | |
811 | // that are structurally recursive. If we don't catch this case, we | |
812 | // will recurse infinitely for some inputs. | |
813 | // | |
814 | // It is important that we DO take generic parameters into account | |
815 | // here, so that code like this is considered SelfRecursive, not | |
816 | // ContainsRecursive: | |
817 | // | |
818 | // struct Foo { Option<Option<Foo>> } | |
819 | ||
820 | for &seen_type in iter { | |
821 | if same_type(ty, seen_type) { | |
822 | debug!("ContainsRecursive: {:?} contains {:?}", | |
823 | seen_type, | |
824 | ty); | |
825 | return Representability::ContainsRecursive; | |
826 | } | |
827 | } | |
828 | } | |
829 | ||
830 | // For structs and enums, track all previously seen types by pushing them | |
831 | // onto the 'seen' stack. | |
832 | seen.push(ty); | |
041b39d2 | 833 | let out = are_inner_types_recursive(tcx, sp, seen, representable_cache, ty); |
e9174d1e SL |
834 | seen.pop(); |
835 | out | |
836 | } | |
837 | _ => { | |
838 | // No need to push in other cases. | |
041b39d2 | 839 | are_inner_types_recursive(tcx, sp, seen, representable_cache, ty) |
e9174d1e SL |
840 | } |
841 | } | |
842 | } | |
843 | ||
844 | debug!("is_type_representable: {:?}", self); | |
845 | ||
846 | // To avoid a stack overflow when checking an enum variant or struct that | |
847 | // contains a different, structurally recursive type, maintain a stack | |
848 | // of seen types and check recursion for each of them (issues #3008, #3779). | |
849 | let mut seen: Vec<Ty> = Vec::new(); | |
041b39d2 XL |
850 | let mut representable_cache = FxHashMap(); |
851 | let r = is_type_structurally_recursive( | |
852 | tcx, sp, &mut seen, &mut representable_cache, self); | |
e9174d1e SL |
853 | debug!("is_type_representable: {:?} is {:?}", self, r); |
854 | r | |
855 | } | |
856 | } | |
7cac9316 XL |
857 | |
858 | fn is_copy_raw<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
859 | query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) | |
860 | -> bool | |
861 | { | |
862 | let (param_env, ty) = query.into_parts(); | |
863 | let trait_def_id = tcx.require_lang_item(lang_items::CopyTraitLangItem); | |
041b39d2 | 864 | tcx.infer_ctxt() |
7cac9316 XL |
865 | .enter(|infcx| traits::type_known_to_meet_bound(&infcx, |
866 | param_env, | |
867 | ty, | |
868 | trait_def_id, | |
869 | DUMMY_SP)) | |
870 | } | |
871 | ||
872 | fn is_sized_raw<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
873 | query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) | |
874 | -> bool | |
875 | { | |
876 | let (param_env, ty) = query.into_parts(); | |
877 | let trait_def_id = tcx.require_lang_item(lang_items::SizedTraitLangItem); | |
041b39d2 | 878 | tcx.infer_ctxt() |
7cac9316 XL |
879 | .enter(|infcx| traits::type_known_to_meet_bound(&infcx, |
880 | param_env, | |
881 | ty, | |
882 | trait_def_id, | |
883 | DUMMY_SP)) | |
884 | } | |
885 | ||
886 | fn is_freeze_raw<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
887 | query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) | |
888 | -> bool | |
889 | { | |
890 | let (param_env, ty) = query.into_parts(); | |
891 | let trait_def_id = tcx.require_lang_item(lang_items::FreezeTraitLangItem); | |
041b39d2 | 892 | tcx.infer_ctxt() |
7cac9316 XL |
893 | .enter(|infcx| traits::type_known_to_meet_bound(&infcx, |
894 | param_env, | |
895 | ty, | |
896 | trait_def_id, | |
897 | DUMMY_SP)) | |
898 | } | |
899 | ||
900 | fn needs_drop_raw<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, | |
901 | query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) | |
902 | -> bool | |
903 | { | |
904 | let (param_env, ty) = query.into_parts(); | |
905 | ||
906 | let needs_drop = |ty: Ty<'tcx>| -> bool { | |
94b46f34 | 907 | match tcx.try_needs_drop_raw(DUMMY_SP, param_env.and(ty)) { |
7cac9316 | 908 | Ok(v) => v, |
3b2f2976 | 909 | Err(mut bug) => { |
7cac9316 XL |
910 | // Cycles should be reported as an error by `check_representable`. |
911 | // | |
3b2f2976 XL |
912 | // Consider the type as not needing drop in the meanwhile to |
913 | // avoid further errors. | |
914 | // | |
915 | // In case we forgot to emit a bug elsewhere, delay our | |
916 | // diagnostic to get emitted as a compiler bug. | |
917 | bug.delay_as_bug(); | |
7cac9316 XL |
918 | false |
919 | } | |
920 | } | |
921 | }; | |
922 | ||
923 | assert!(!ty.needs_infer()); | |
924 | ||
925 | match ty.sty { | |
926 | // Fast-path for primitive types | |
b7449926 XL |
927 | ty::Infer(ty::FreshIntTy(_)) | ty::Infer(ty::FreshFloatTy(_)) | |
928 | ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Never | | |
929 | ty::FnDef(..) | ty::FnPtr(_) | ty::Char | ty::GeneratorWitness(..) | | |
930 | ty::RawPtr(_) | ty::Ref(..) | ty::Str => false, | |
7cac9316 | 931 | |
abe05a73 | 932 | // Foreign types can never have destructors |
b7449926 | 933 | ty::Foreign(..) => false, |
abe05a73 | 934 | |
8faf50e0 | 935 | // `ManuallyDrop` doesn't have a destructor regardless of field types. |
b7449926 | 936 | ty::Adt(def, _) if Some(def.did) == tcx.lang_items().manually_drop() => false, |
8faf50e0 | 937 | |
7cac9316 XL |
938 | // Issue #22536: We first query type_moves_by_default. It sees a |
939 | // normalized version of the type, and therefore will definitely | |
940 | // know whether the type implements Copy (and thus needs no | |
941 | // cleanup/drop/zeroing) ... | |
942 | _ if !ty.moves_by_default(tcx, param_env, DUMMY_SP) => false, | |
943 | ||
944 | // ... (issue #22536 continued) but as an optimization, still use | |
945 | // prior logic of asking for the structural "may drop". | |
946 | ||
947 | // FIXME(#22815): Note that this is a conservative heuristic; | |
948 | // it may report that the type "may drop" when actual type does | |
949 | // not actually have a destructor associated with it. But since | |
950 | // the type absolutely did not have the `Copy` bound attached | |
951 | // (see above), it is sound to treat it as having a destructor. | |
952 | ||
953 | // User destructors are the only way to have concrete drop types. | |
b7449926 | 954 | ty::Adt(def, _) if def.has_dtor(tcx) => true, |
7cac9316 XL |
955 | |
956 | // Can refer to a type which may drop. | |
957 | // FIXME(eddyb) check this against a ParamEnv. | |
b7449926 XL |
958 | ty::Dynamic(..) | ty::Projection(..) | ty::Param(_) | |
959 | ty::Opaque(..) | ty::Infer(_) | ty::Error => true, | |
7cac9316 XL |
960 | |
961 | // Structural recursion. | |
b7449926 | 962 | ty::Array(ty, _) | ty::Slice(ty) => needs_drop(ty), |
7cac9316 | 963 | |
b7449926 | 964 | ty::Closure(def_id, ref substs) => substs.upvar_tys(def_id, tcx).any(needs_drop), |
7cac9316 | 965 | |
ea8adc8c XL |
966 | // Pessimistically assume that all generators will require destructors |
967 | // as we don't know if a destructor is a noop or not until after the MIR | |
968 | // state transformation pass | |
b7449926 | 969 | ty::Generator(..) => true, |
ea8adc8c | 970 | |
b7449926 | 971 | ty::Tuple(ref tys) => tys.iter().cloned().any(needs_drop), |
7cac9316 | 972 | |
8faf50e0 XL |
973 | // unions don't have destructors because of the child types, |
974 | // only if they manually implement `Drop` (handled above). | |
b7449926 | 975 | ty::Adt(def, _) if def.is_union() => false, |
7cac9316 | 976 | |
b7449926 | 977 | ty::Adt(def, substs) => |
7cac9316 XL |
978 | def.variants.iter().any( |
979 | |variant| variant.fields.iter().any( | |
980 | |field| needs_drop(field.ty(tcx, substs)))), | |
981 | } | |
982 | } | |
983 | ||
abe05a73 XL |
984 | pub enum ExplicitSelf<'tcx> { |
985 | ByValue, | |
986 | ByReference(ty::Region<'tcx>, hir::Mutability), | |
ff7c6d11 | 987 | ByRawPointer(hir::Mutability), |
abe05a73 XL |
988 | ByBox, |
989 | Other | |
990 | } | |
991 | ||
992 | impl<'tcx> ExplicitSelf<'tcx> { | |
993 | /// Categorizes an explicit self declaration like `self: SomeType` | |
994 | /// into either `self`, `&self`, `&mut self`, `Box<self>`, or | |
995 | /// `Other`. | |
996 | /// This is mainly used to require the arbitrary_self_types feature | |
997 | /// in the case of `Other`, to improve error messages in the common cases, | |
998 | /// and to make `Other` non-object-safe. | |
999 | /// | |
1000 | /// Examples: | |
1001 | /// | |
1002 | /// ``` | |
1003 | /// impl<'a> Foo for &'a T { | |
1004 | /// // Legal declarations: | |
1005 | /// fn method1(self: &&'a T); // ExplicitSelf::ByReference | |
1006 | /// fn method2(self: &'a T); // ExplicitSelf::ByValue | |
1007 | /// fn method3(self: Box<&'a T>); // ExplicitSelf::ByBox | |
1008 | /// fn method4(self: Rc<&'a T>); // ExplicitSelf::Other | |
1009 | /// | |
1010 | /// // Invalid cases will be caught by `check_method_receiver`: | |
1011 | /// fn method_err1(self: &'a mut T); // ExplicitSelf::Other | |
1012 | /// fn method_err2(self: &'static T) // ExplicitSelf::ByValue | |
1013 | /// fn method_err3(self: &&T) // ExplicitSelf::ByReference | |
1014 | /// } | |
1015 | /// ``` | |
1016 | /// | |
1017 | pub fn determine<P>( | |
1018 | self_arg_ty: Ty<'tcx>, | |
1019 | is_self_ty: P | |
1020 | ) -> ExplicitSelf<'tcx> | |
1021 | where | |
1022 | P: Fn(Ty<'tcx>) -> bool | |
1023 | { | |
1024 | use self::ExplicitSelf::*; | |
1025 | ||
1026 | match self_arg_ty.sty { | |
1027 | _ if is_self_ty(self_arg_ty) => ByValue, | |
b7449926 | 1028 | ty::Ref(region, ty, mutbl) if is_self_ty(ty) => { |
abe05a73 XL |
1029 | ByReference(region, mutbl) |
1030 | } | |
b7449926 | 1031 | ty::RawPtr(ty::TypeAndMut { ty, mutbl }) if is_self_ty(ty) => { |
ff7c6d11 XL |
1032 | ByRawPointer(mutbl) |
1033 | } | |
b7449926 | 1034 | ty::Adt(def, _) if def.is_box() && is_self_ty(self_arg_ty.boxed_ty()) => { |
ff7c6d11 XL |
1035 | ByBox |
1036 | } | |
abe05a73 XL |
1037 | _ => Other |
1038 | } | |
1039 | } | |
1040 | } | |
1041 | ||
94b46f34 XL |
1042 | pub fn provide(providers: &mut ty::query::Providers) { |
1043 | *providers = ty::query::Providers { | |
7cac9316 XL |
1044 | is_copy_raw, |
1045 | is_sized_raw, | |
1046 | is_freeze_raw, | |
1047 | needs_drop_raw, | |
7cac9316 XL |
1048 | ..*providers |
1049 | }; | |
1050 | } |