diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index de187a3f5e0dc..87885e40222f4 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -95,8 +95,8 @@ provide! { <'tcx> tcx, def_id, other, cdata, generics_of => { tcx.arena.alloc(cdata.get_generics(def_id.index, tcx.sess)) } - predicates_of => { cdata.get_predicates(def_id.index, tcx) } - predicates_defined_on => { cdata.get_predicates_defined_on(def_id.index, tcx) } + explicit_predicates_of => { cdata.get_explicit_predicates(def_id.index, tcx) } + inferred_outlives_of => { cdata.get_inferred_outlives(def_id.index, tcx) } super_predicates_of => { cdata.get_super_predicates(def_id.index, tcx) } trait_def => { tcx.arena.alloc(cdata.get_trait_def(def_id.index, tcx.sess)) diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index c5954e1ea1d98..771d01a4b6a1d 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -658,20 +658,22 @@ impl<'a, 'tcx> CrateMetadata { tcx.alloc_adt_def(did, adt_kind, variants, repr) } - crate fn get_predicates( + crate fn get_explicit_predicates( &self, item_id: DefIndex, tcx: TyCtxt<'tcx>, ) -> ty::GenericPredicates<'tcx> { - self.root.per_def.predicates.get(self, item_id).unwrap().decode((self, tcx)) + self.root.per_def.explicit_predicates.get(self, item_id).unwrap().decode((self, tcx)) } - crate fn get_predicates_defined_on( + crate fn get_inferred_outlives( &self, item_id: DefIndex, tcx: TyCtxt<'tcx>, - ) -> ty::GenericPredicates<'tcx> { - self.root.per_def.predicates_defined_on.get(self, item_id).unwrap().decode((self, tcx)) + ) -> &'tcx [(ty::Predicate<'tcx>, Span)] { + self.root.per_def.inferred_outlives.get(self, item_id).map(|predicates| { + predicates.decode((self, tcx)) + }).unwrap_or_default() } crate fn get_super_predicates( diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index f2b0cfa530508..05cc63a01f306 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -76,8 +76,8 @@ struct PerDefTables<'tcx> { inherent_impls: PerDefTable>, variances: PerDefTable>, generics: PerDefTable>, - predicates: PerDefTable>>, - predicates_defined_on: PerDefTable>>, + explicit_predicates: PerDefTable>>, + inferred_outlives: PerDefTable, Span)]>>, super_predicates: PerDefTable>>, mir: PerDefTable>>, @@ -524,8 +524,8 @@ impl<'tcx> EncodeContext<'tcx> { inherent_impls: self.per_def.inherent_impls.encode(&mut self.opaque), variances: self.per_def.variances.encode(&mut self.opaque), generics: self.per_def.generics.encode(&mut self.opaque), - predicates: self.per_def.predicates.encode(&mut self.opaque), - predicates_defined_on: self.per_def.predicates_defined_on.encode(&mut self.opaque), + explicit_predicates: self.per_def.explicit_predicates.encode(&mut self.opaque), + inferred_outlives: self.per_def.inferred_outlives.encode(&mut self.opaque), super_predicates: self.per_def.super_predicates.encode(&mut self.opaque), mir: self.per_def.mir.encode(&mut self.opaque), @@ -676,7 +676,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_explicit_predicates(def_id); + self.encode_inferred_outlives(def_id); self.encode_optimized_mir(def_id); self.encode_promoted_mir(def_id); } @@ -719,7 +720,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_explicit_predicates(def_id); + self.encode_inferred_outlives(def_id); self.encode_optimized_mir(def_id); self.encode_promoted_mir(def_id); } @@ -777,7 +779,8 @@ impl EncodeContext<'tcx> { self.encode_deprecation(def_id); self.encode_item_type(def_id); self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_explicit_predicates(def_id); + self.encode_inferred_outlives(def_id); } fn encode_struct_ctor(&mut self, adt_def_id: DefId, def_id: DefId) { @@ -820,7 +823,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_explicit_predicates(def_id); + self.encode_inferred_outlives(def_id); self.encode_optimized_mir(def_id); self.encode_promoted_mir(def_id); } @@ -830,15 +834,18 @@ impl EncodeContext<'tcx> { record!(self.per_def.generics[def_id] <- self.tcx.generics_of(def_id)); } - fn encode_predicates(&mut self, def_id: DefId) { - debug!("EncodeContext::encode_predicates({:?})", def_id); - record!(self.per_def.predicates[def_id] <- self.tcx.predicates_of(def_id)); + fn encode_explicit_predicates(&mut self, def_id: DefId) { + debug!("EncodeContext::encode_explicit_predicates({:?})", def_id); + record!(self.per_def.explicit_predicates[def_id] <- + self.tcx.explicit_predicates_of(def_id)); } - fn encode_predicates_defined_on(&mut self, def_id: DefId) { - debug!("EncodeContext::encode_predicates_defined_on({:?})", def_id); - record!(self.per_def.predicates_defined_on[def_id] <- - self.tcx.predicates_defined_on(def_id)) + fn encode_inferred_outlives(&mut self, def_id: DefId) { + debug!("EncodeContext::encode_inferred_outlives({:?})", def_id); + let inferred_outlives = self.tcx.inferred_outlives_of(def_id); + if !inferred_outlives.is_empty() { + record!(self.per_def.inferred_outlives[def_id] <- inferred_outlives); + } } fn encode_super_predicates(&mut self, def_id: DefId) { @@ -920,7 +927,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_explicit_predicates(def_id); + self.encode_inferred_outlives(def_id); self.encode_optimized_mir(def_id); self.encode_promoted_mir(def_id); } @@ -987,7 +995,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_explicit_predicates(def_id); + self.encode_inferred_outlives(def_id); let mir = match ast_item.kind { hir::ImplItemKind::Const(..) => true, hir::ImplItemKind::Method(ref sig, _) => { @@ -1261,22 +1270,11 @@ impl EncodeContext<'tcx> { hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..) => { self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_explicit_predicates(def_id); + self.encode_inferred_outlives(def_id); } _ => {} } - // The only time that `predicates_defined_on` is used (on - // an external item) is for traits, during chalk lowering, - // so only encode it in that case as an efficiency - // hack. (No reason not to expand it in the future if - // necessary.) - match item.kind { - hir::ItemKind::Trait(..) | - hir::ItemKind::TraitAlias(..) => { - self.encode_predicates_defined_on(def_id); - } - _ => {} // not *wrong* for other kinds of items, but not needed - } match item.kind { hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..) => { @@ -1378,7 +1376,8 @@ impl EncodeContext<'tcx> { record!(self.per_def.span[def_id] <- self.tcx.def_span(def_id)); self.encode_item_type(def_id); self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_explicit_predicates(def_id); + self.encode_inferred_outlives(def_id); self.encode_optimized_mir(def_id); self.encode_promoted_mir(def_id); } @@ -1589,7 +1588,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_explicit_predicates(def_id); + self.encode_inferred_outlives(def_id); } } diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs index 8bece2511166e..f644b7264320b 100644 --- a/src/librustc_metadata/schema.rs +++ b/src/librustc_metadata/schema.rs @@ -244,8 +244,13 @@ crate struct LazyPerDefTables<'tcx> { pub inherent_impls: Lazy!(PerDefTable>), pub variances: Lazy!(PerDefTable>), pub generics: Lazy!(PerDefTable>), - pub predicates: Lazy!(PerDefTable)>), - pub predicates_defined_on: Lazy!(PerDefTable)>), + pub explicit_predicates: Lazy!(PerDefTable)>), + // FIXME(eddyb) this would ideally be `Lazy<[...]>` but `ty::Predicate` + // doesn't handle shorthands in its own (de)serialization impls, + // as it's an `enum` for which we want to derive (de)serialization, + // so the `ty::codec` APIs handle the whole `&'tcx [...]` at once. + // Also, as an optimization, a missing entry indicates an empty `&[]`. + pub inferred_outlives: Lazy!(PerDefTable, Span)])>), pub super_predicates: Lazy!(PerDefTable)>), pub mir: Lazy!(PerDefTable)>), diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 001d98aece2a0..9ae8f2d607899 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -1142,10 +1142,6 @@ fn report_assoc_ty_on_inherent_impl(tcx: TyCtxt<'_>, span: Span) { ); } -fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { - checked_type_of(tcx, def_id, true).unwrap() -} - fn infer_placeholder_type( tcx: TyCtxt<'_>, def_id: DefId, @@ -1189,26 +1185,14 @@ fn infer_placeholder_type( ty } -/// Same as [`type_of`] but returns [`Option`] instead of failing. -/// -/// If you want to fail anyway, you can set the `fail` parameter to true, but in this case, -/// you'd better just call [`type_of`] directly. -pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option> { +fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { use rustc::hir::*; - let hir_id = match tcx.hir().as_local_hir_id(def_id) { - Some(hir_id) => hir_id, - None => { - if !fail { - return None; - } - bug!("invalid node"); - } - }; + let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); let icx = ItemCtxt::new(tcx, def_id); - Some(match tcx.hir().get(hir_id) { + match tcx.hir().get(hir_id) { Node::TraitItem(item) => match item.kind { TraitItemKind::Method(..) => { let substs = InternalSubsts::identity_for_item(tcx, def_id); @@ -1225,9 +1209,6 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option icx.to_ty(ty), TraitItemKind::Type(_, None) => { - if !fail { - return None; - } span_bug!(item.span, "associated type missing default"); } }, @@ -1321,9 +1302,6 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option { - if !fail { - return None; - } span_bug!( item.span, "compute_type_of_item: unexpected item type: {:?}", @@ -1361,7 +1339,7 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option { if gen.is_some() { - return Some(tcx.typeck_tables_of(def_id).node_type(hir_id)); + return tcx.typeck_tables_of(def_id).node_type(hir_id); } let substs = InternalSubsts::identity_for_item(tcx, def_id); @@ -1436,13 +1414,9 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option, def_id: DefId, fail: bool) -> Option tcx.generics_of(def_id), - Res::Err => return Some(tcx.types.err), - _ if !fail => return None, + Res::Err => return tcx.types.err, res => { tcx.sess.delay_span_bug( DUMMY_SP, @@ -1462,7 +1435,7 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option, def_id: DefId, fail: bool) -> Option, def_id: DefId, fail: bool) -> Option { - if !fail { - return None; - } tcx.sess.delay_span_bug( DUMMY_SP, &format!( @@ -1547,21 +1514,13 @@ pub fn checked_type_of(tcx: TyCtxt<'_>, def_id: DefId, fail: bool) -> Option { - if !fail { - return None; - } - bug!("unexpected non-type Node::GenericParam: {:?}", x) - }, + x => bug!("unexpected non-type Node::GenericParam: {:?}", x), }, x => { - if !fail { - return None; - } bug!("unexpected sort of node in type_of_def_id(): {:?}", x); } - }) + } } fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { @@ -2071,10 +2030,7 @@ fn explicit_predicates_of( } } - let hir_id = match tcx.hir().as_local_hir_id(def_id) { - Some(hir_id) => hir_id, - None => return tcx.predicates_of(def_id), - }; + let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); let node = tcx.hir().get(hir_id); let mut is_trait = None; diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 9374113e1c950..a5a4cfa2babc0 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -109,8 +109,6 @@ use util::common::time; use std::iter; use astconv::{AstConv, Bounds}; -pub use collect::checked_type_of; - pub struct TypeAndSubsts<'tcx> { substs: SubstsRef<'tcx>, ty: Ty<'tcx>, diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index bdc0206223036..a8a3f54ef5a8f 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1491,12 +1491,13 @@ impl GenericParamDefKind { } } - pub fn get_type(&self, cx: &DocContext<'_>) -> Option { - match *self { - GenericParamDefKind::Type { did, .. } => { - rustc_typeck::checked_type_of(cx.tcx, did, false).map(|t| t.clean(cx)) - } - GenericParamDefKind::Const { ref ty, .. } => Some(ty.clone()), + // FIXME(eddyb) this either returns the default of a type parameter, or the + // type of a `const` parameter. It seems that the intention is to *visit* + // any embedded types, but `get_type` seems to be the wrong name for that. + pub fn get_type(&self) -> Option { + match self { + GenericParamDefKind::Type { default, .. } => default.clone(), + GenericParamDefKind::Const { ty, .. } => Some(ty.clone()), GenericParamDefKind::Lifetime => None, } } @@ -1522,8 +1523,8 @@ impl GenericParamDef { self.kind.is_type() } - pub fn get_type(&self, cx: &DocContext<'_>) -> Option { - self.kind.get_type(cx) + pub fn get_type(&self) -> Option { + self.kind.get_type() } pub fn get_bounds(&self) -> Option<&[GenericBound]> { @@ -1891,7 +1892,7 @@ fn get_real_types( if !x.is_type() { continue } - if let Some(ty) = x.get_type(cx) { + if let Some(ty) = x.get_type() { let adds = get_real_types(generics, &ty, cx, recurse + 1); if !adds.is_empty() { res.extend(adds);