From 9b19cc0c215217e2423173bf8ef346f882238f8c Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Sat, 6 Apr 2019 16:55:24 +0300 Subject: [PATCH 1/5] Revert "Fix invalid bounds string generation in rustdoc" This reverts commit ddd034aa6f04e7f452bca398e3982c4a5ef6c0bc. --- src/librustc_typeck/collect.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 001d98aece2..e07f0ffdc34 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -2071,10 +2071,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; From 9e528ffe9c32b9a6b3be7554aa7929abb77b83a1 Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Mon, 8 Apr 2019 09:54:26 +0300 Subject: [PATCH 2/5] Revert "Greatly improve generics handling in rustdoc search" This reverts commit 64382f4b78bdca6bea1dd06e4a1039646b04ae93. --- src/librustc_typeck/collect.rs | 65 +++++++--------------------------- src/librustc_typeck/lib.rs | 2 -- src/librustdoc/clean/mod.rs | 19 +++++----- 3 files changed, 22 insertions(+), 64 deletions(-) diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index e07f0ffdc34..9ae8f2d6078 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<'_> { diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 9374113e1c9..a5a4cfa2bab 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 bdc02062230..a8a3f54ef5a 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); From 71eacef414d076380287dbade8d6cc62e49ff270 Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Mon, 8 Apr 2019 13:15:29 +0300 Subject: [PATCH 3/5] rustc_metadata: remove predicates_of and rely on predicates_defined_on alone. --- src/librustc_metadata/cstore_impl.rs | 1 - src/librustc_metadata/decoder.rs | 8 ------ src/librustc_metadata/encoder.rs | 37 +++++++--------------------- src/librustc_metadata/schema.rs | 1 - 4 files changed, 9 insertions(+), 38 deletions(-) diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index de187a3f5e0..aade35fe04a 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -95,7 +95,6 @@ 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) } super_predicates_of => { cdata.get_super_predicates(def_id.index, tcx) } trait_def => { diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index c5954e1ea1d..879d43f7fd3 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -658,14 +658,6 @@ impl<'a, 'tcx> CrateMetadata { tcx.alloc_adt_def(did, adt_kind, variants, repr) } - crate fn get_predicates( - &self, - item_id: DefIndex, - tcx: TyCtxt<'tcx>, - ) -> ty::GenericPredicates<'tcx> { - self.root.per_def.predicates.get(self, item_id).unwrap().decode((self, tcx)) - } - crate fn get_predicates_defined_on( &self, item_id: DefIndex, diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index f2b0cfa5305..eb254f09158 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -76,7 +76,6 @@ struct PerDefTables<'tcx> { inherent_impls: PerDefTable>, variances: PerDefTable>, generics: PerDefTable>, - predicates: PerDefTable>>, predicates_defined_on: PerDefTable>>, super_predicates: PerDefTable>>, @@ -524,7 +523,6 @@ 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), super_predicates: self.per_def.super_predicates.encode(&mut self.opaque), @@ -676,7 +674,7 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_predicates_defined_on(def_id); self.encode_optimized_mir(def_id); self.encode_promoted_mir(def_id); } @@ -719,7 +717,7 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_predicates_defined_on(def_id); self.encode_optimized_mir(def_id); self.encode_promoted_mir(def_id); } @@ -777,7 +775,7 @@ 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_predicates_defined_on(def_id); } fn encode_struct_ctor(&mut self, adt_def_id: DefId, def_id: DefId) { @@ -820,7 +818,7 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_predicates_defined_on(def_id); self.encode_optimized_mir(def_id); self.encode_promoted_mir(def_id); } @@ -830,11 +828,6 @@ 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_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] <- @@ -920,7 +913,7 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_predicates_defined_on(def_id); self.encode_optimized_mir(def_id); self.encode_promoted_mir(def_id); } @@ -987,7 +980,7 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_predicates_defined_on(def_id); let mir = match ast_item.kind { hir::ImplItemKind::Const(..) => true, hir::ImplItemKind::Method(ref sig, _) => { @@ -1261,21 +1254,9 @@ impl EncodeContext<'tcx> { hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..) => { self.encode_generics(def_id); - self.encode_predicates(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(..) | @@ -1378,7 +1359,7 @@ 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_predicates_defined_on(def_id); self.encode_optimized_mir(def_id); self.encode_promoted_mir(def_id); } @@ -1589,7 +1570,7 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates(def_id); + self.encode_predicates_defined_on(def_id); } } diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs index 8bece251116..eb2de0e9783 100644 --- a/src/librustc_metadata/schema.rs +++ b/src/librustc_metadata/schema.rs @@ -244,7 +244,6 @@ 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 super_predicates: Lazy!(PerDefTable)>), From cd7cbaa38d852507d594de7143351bf2e44cc7c4 Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Tue, 9 Apr 2019 23:17:56 +0300 Subject: [PATCH 4/5] rustc_metadata: replace predicates_defined_on with explicit_predicates_of and inferred_outlives_of. --- src/librustc_metadata/cstore_impl.rs | 3 +- src/librustc_metadata/decoder.rs | 12 +++++-- src/librustc_metadata/encoder.rs | 47 +++++++++++++++++++--------- src/librustc_metadata/schema.rs | 7 ++++- 4 files changed, 50 insertions(+), 19 deletions(-) diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index aade35fe04a..87885e40222 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -95,7 +95,8 @@ provide! { <'tcx> tcx, def_id, other, cdata, generics_of => { tcx.arena.alloc(cdata.get_generics(def_id.index, tcx.sess)) } - 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 879d43f7fd3..48809377744 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -658,12 +658,20 @@ impl<'a, 'tcx> CrateMetadata { tcx.alloc_adt_def(did, adt_kind, variants, repr) } - crate fn get_predicates_defined_on( + crate fn get_explicit_predicates( &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)) + self.root.per_def.explicit_predicates.get(self, item_id).unwrap().decode((self, tcx)) + } + + crate fn get_inferred_outlives( + &self, + item_id: DefIndex, + tcx: TyCtxt<'tcx>, + ) -> &'tcx [(ty::Predicate<'tcx>, Span)] { + self.root.per_def.inferred_outlives.get(self, item_id).unwrap().decode((self, tcx)) } crate fn get_super_predicates( diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index eb254f09158..db00095b929 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -76,7 +76,8 @@ struct PerDefTables<'tcx> { inherent_impls: PerDefTable>, variances: PerDefTable>, generics: PerDefTable>, - predicates_defined_on: PerDefTable>>, + explicit_predicates: PerDefTable>>, + inferred_outlives: PerDefTable, Span)]>>, super_predicates: PerDefTable>>, mir: PerDefTable>>, @@ -523,7 +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_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), @@ -674,7 +676,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates_defined_on(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); } @@ -717,7 +720,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates_defined_on(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); } @@ -775,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_defined_on(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) { @@ -818,7 +823,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates_defined_on(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); } @@ -828,10 +834,16 @@ impl EncodeContext<'tcx> { record!(self.per_def.generics[def_id] <- self.tcx.generics_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_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_inferred_outlives(&mut self, def_id: DefId) { + debug!("EncodeContext::encode_inferred_outlives({:?})", def_id); + record!(self.per_def.inferred_outlives[def_id] <- + self.tcx.inferred_outlives_of(def_id)); } fn encode_super_predicates(&mut self, def_id: DefId) { @@ -913,7 +925,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates_defined_on(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); } @@ -980,7 +993,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates_defined_on(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, _) => { @@ -1254,7 +1268,8 @@ impl EncodeContext<'tcx> { hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..) => { self.encode_generics(def_id); - self.encode_predicates_defined_on(def_id); + self.encode_explicit_predicates(def_id); + self.encode_inferred_outlives(def_id); } _ => {} } @@ -1359,7 +1374,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_defined_on(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); } @@ -1570,7 +1586,8 @@ impl EncodeContext<'tcx> { self.encode_variances_of(def_id); } self.encode_generics(def_id); - self.encode_predicates_defined_on(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 eb2de0e9783..b459d53eb51 100644 --- a/src/librustc_metadata/schema.rs +++ b/src/librustc_metadata/schema.rs @@ -244,7 +244,12 @@ crate struct LazyPerDefTables<'tcx> { pub inherent_impls: Lazy!(PerDefTable>), pub variances: Lazy!(PerDefTable>), pub generics: 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. + pub inferred_outlives: Lazy!(PerDefTable, Span)])>), pub super_predicates: Lazy!(PerDefTable)>), pub mir: Lazy!(PerDefTable)>), From d594fc2562106a75b55c66a7d0eda0d99b333756 Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Wed, 10 Apr 2019 23:27:39 +0300 Subject: [PATCH 5/5] rustc_metadata: don't encode an empty slice for inferred_outlives. --- src/librustc_metadata/decoder.rs | 4 +++- src/librustc_metadata/encoder.rs | 6 ++++-- src/librustc_metadata/schema.rs | 1 + 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index 48809377744..771d01a4b6a 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -671,7 +671,9 @@ impl<'a, 'tcx> CrateMetadata { item_id: DefIndex, tcx: TyCtxt<'tcx>, ) -> &'tcx [(ty::Predicate<'tcx>, Span)] { - self.root.per_def.inferred_outlives.get(self, item_id).unwrap().decode((self, tcx)) + 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 db00095b929..05cc63a01f3 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -842,8 +842,10 @@ impl EncodeContext<'tcx> { fn encode_inferred_outlives(&mut self, def_id: DefId) { debug!("EncodeContext::encode_inferred_outlives({:?})", def_id); - record!(self.per_def.inferred_outlives[def_id] <- - self.tcx.inferred_outlives_of(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) { diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs index b459d53eb51..f644b726432 100644 --- a/src/librustc_metadata/schema.rs +++ b/src/librustc_metadata/schema.rs @@ -249,6 +249,7 @@ crate struct LazyPerDefTables<'tcx> { // 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)>),