Use SpanId in inferred_outlives_of.

Author: cjgillot

src/librustc_infer/traits/util.rs

@@ -4,7 +4,7 @@ use crate::traits::{Obligation, ObligationCause, PredicateObligation};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_middle::ty::outlives::Component;
 use rustc_middle::ty::{self, ToPolyTraitRef, ToPredicate, TyCtxt, WithConstness};
-use rustc_span::Span;
+use rustc_span::SpanId;
 
 pub fn anonymize_predicate<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -112,7 +112,8 @@ pub fn elaborate_predicates<'tcx>(
     tcx: TyCtxt<'tcx>,
     predicates: impl Iterator<Item = ty::Predicate<'tcx>>,
 ) -> Elaborator<'tcx> {
-    let obligations = predicates.map(|predicate| predicate_obligation(predicate, None)).collect();
+    let obligations =
+        predicates.map(|predicate| predicate_obligation(tcx, predicate, None)).collect();
     elaborate_obligations(tcx, obligations)
 }
 
@@ -126,12 +127,13 @@ pub fn elaborate_obligations<'tcx>(
 }
 
 fn predicate_obligation<'tcx>(
+    tcx: TyCtxt<'tcx>,
     predicate: ty::Predicate<'tcx>,
-    span: Option<Span>,
+    span: Option<SpanId>,
 ) -> PredicateObligation<'tcx> {
     let mut cause = ObligationCause::dummy();
     if let Some(span) = span {
-        cause.span = span;
+        cause.span = tcx.reify_span(span);
     }
     Obligation { cause, param_env: ty::ParamEnv::empty(), recursion_depth: 0, predicate }
 }
@@ -150,6 +152,7 @@ impl Elaborator<'tcx> {
 
                 let obligations = predicates.predicates.iter().map(|(pred, span)| {
                     predicate_obligation(
+                        tcx,
                         pred.subst_supertrait(tcx, &data.to_poly_trait_ref()),
                         Some(*span),
                     )
@@ -245,7 +248,7 @@ impl Elaborator<'tcx> {
                             }
                         })
                         .filter(|p| visited.insert(p))
-                        .map(|p| predicate_obligation(p, None)),
+                        .map(|p| predicate_obligation(tcx, p, None)),
                 );
             }
         }

src/librustc_lint/builtin.rs

@@ -42,7 +42,7 @@ use rustc_session::lint::FutureIncompatibleInfo;
 use rustc_span::edition::Edition;
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
-use rustc_span::{BytePos, Span};
+use rustc_span::{BytePos, Span, SpanId};
 use rustc_target::abi::VariantIdx;
 use rustc_trait_selection::traits::misc::can_type_implement_copy;
 
@@ -1491,7 +1491,7 @@ declare_lint_pass!(ExplicitOutlivesRequirements => [EXPLICIT_OUTLIVES_REQUIREMEN
 
 impl ExplicitOutlivesRequirements {
     fn lifetimes_outliving_lifetime<'tcx>(
-        inferred_outlives: &'tcx [(ty::Predicate<'tcx>, Span)],
+        inferred_outlives: &'tcx [(ty::Predicate<'tcx>, SpanId)],
         index: u32,
     ) -> Vec<ty::Region<'tcx>> {
         inferred_outlives
@@ -1510,7 +1510,7 @@ impl ExplicitOutlivesRequirements {
     }
 
     fn lifetimes_outliving_type<'tcx>(
-        inferred_outlives: &'tcx [(ty::Predicate<'tcx>, Span)],
+        inferred_outlives: &'tcx [(ty::Predicate<'tcx>, SpanId)],
         index: u32,
     ) -> Vec<ty::Region<'tcx>> {
         inferred_outlives
@@ -1529,7 +1529,7 @@ impl ExplicitOutlivesRequirements {
         &self,
         param: &'tcx hir::GenericParam<'tcx>,
         tcx: TyCtxt<'tcx>,
-        inferred_outlives: &'tcx [(ty::Predicate<'tcx>, Span)],
+        inferred_outlives: &'tcx [(ty::Predicate<'tcx>, SpanId)],
         ty_generics: &'tcx ty::Generics,
     ) -> Vec<ty::Region<'tcx>> {
         let index =

src/librustc_metadata/rmeta/decoder.rs

@@ -34,7 +34,7 @@ use rustc_serialize::{opaque, Decodable, Decoder, SpecializedDecoder};
 use rustc_session::Session;
 use rustc_span::source_map::{respan, Spanned};
 use rustc_span::symbol::{sym, Ident, Symbol};
-use rustc_span::{self, hygiene::MacroKind, BytePos, Pos, Span, DUMMY_SP};
+use rustc_span::{self, hygiene::MacroKind, BytePos, Pos, Span, SpanId, DUMMY_SP};
 
 use log::debug;
 use proc_macro::bridge::client::ProcMacro;
@@ -837,7 +837,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         &self,
         item_id: DefIndex,
         tcx: TyCtxt<'tcx>,
-    ) -> &'tcx [(ty::Predicate<'tcx>, Span)] {
+    ) -> &'tcx [(ty::Predicate<'tcx>, SpanId)] {
         self.root
             .tables
             .inferred_outlives

src/librustc_metadata/rmeta/encoder.rs

@@ -253,10 +253,10 @@ impl<'tcx> SpecializedEncoder<interpret::AllocId> for EncodeContext<'tcx> {
     }
 }
 
-impl<'tcx> SpecializedEncoder<&'tcx [(ty::Predicate<'tcx>, Span)]> for EncodeContext<'tcx> {
+impl<'tcx> SpecializedEncoder<&'tcx [(ty::Predicate<'tcx>, SpanId)]> for EncodeContext<'tcx> {
     fn specialized_encode(
         &mut self,
-        predicates: &&'tcx [(ty::Predicate<'tcx>, Span)],
+        predicates: &&'tcx [(ty::Predicate<'tcx>, SpanId)],
     ) -> Result<(), Self::Error> {
         ty_codec::encode_spanned_predicates(self, predicates, |ecx| &mut ecx.predicate_shorthands)
     }

src/librustc_metadata/rmeta/mod.rs

@@ -20,7 +20,7 @@ use rustc_session::config::SymbolManglingVersion;
 use rustc_session::CrateDisambiguator;
 use rustc_span::edition::Edition;
 use rustc_span::symbol::Symbol;
-use rustc_span::{self, Span};
+use rustc_span::{self, Span, SpanId};
 use rustc_target::spec::{PanicStrategy, TargetTriple};
 
 use std::marker::PhantomData;
@@ -273,7 +273,7 @@ define_tables! {
     // 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 `&[]`.
-    inferred_outlives: Table<DefIndex, Lazy!(&'tcx [(ty::Predicate<'tcx>, Span)])>,
+    inferred_outlives: Table<DefIndex, Lazy!(&'tcx [(ty::Predicate<'tcx>, SpanId)])>,
     super_predicates: Table<DefIndex, Lazy!(ty::GenericPredicates<'tcx>)>,
     mir: Table<DefIndex, Lazy!(mir::Body<'tcx>)>,
     promoted_mir: Table<DefIndex, Lazy!(IndexVec<mir::Promoted, mir::Body<'tcx>>)>,

src/librustc_middle/query/mod.rs

@@ -245,7 +245,7 @@ rustc_queries! {
 
         /// Returns the inferred outlives predicates (e.g., for `struct
         /// Foo<'a, T> { x: &'a T }`, this would return `T: 'a`).
-        query inferred_outlives_of(_: DefId) -> &'tcx [(ty::Predicate<'tcx>, Span)] {}
+        query inferred_outlives_of(_: DefId) -> &'tcx [(ty::Predicate<'tcx>, SpanId)] {}
 
         /// Maps from the `DefId` of a trait to the list of
         /// super-predicates. This is a subset of the full list of
@@ -1048,7 +1048,7 @@ rustc_queries! {
             desc { |tcx| "maybe_unused_trait_import for `{}`", tcx.def_path_str(def_id.to_def_id()) }
         }
         query maybe_unused_extern_crates(_: CrateNum)
-            -> &'tcx [(DefId, Span)] {
+            -> &'tcx [(DefId, SpanId)] {
             eval_always
             desc { "looking up all possibly unused extern crates" }
         }

src/librustc_middle/traits/mod.rs

@@ -16,7 +16,7 @@ use crate::ty::{self, AdtKind, Ty, TyCtxt};
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_span::symbol::Symbol;
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::{Span, SpanId, DUMMY_SP, DUMMY_SPID};
 use smallvec::SmallVec;
 
 use std::borrow::Cow;
@@ -568,25 +568,25 @@ pub struct VtableTraitAliasData<'tcx, N> {
 #[derive(Clone, Debug, PartialEq, Eq, Hash, HashStable)]
 pub enum ObjectSafetyViolation {
     /// `Self: Sized` declared on the trait.
-    SizedSelf(SmallVec<[Span; 1]>),
+    SizedSelf(SmallVec<[SpanId; 1]>),
 
     /// Supertrait reference references `Self` an in illegal location
     /// (e.g., `trait Foo : Bar<Self>`).
-    SupertraitSelf(SmallVec<[Span; 1]>),
+    SupertraitSelf(SmallVec<[SpanId; 1]>),
 
     /// Method has something illegal.
-    Method(Symbol, MethodViolationCode, Span),
+    Method(Symbol, MethodViolationCode, SpanId),
 
     /// Associated const.
-    AssocConst(Symbol, Span),
+    AssocConst(Symbol, SpanId),
 }
 
 impl ObjectSafetyViolation {
     pub fn error_msg(&self) -> Cow<'static, str> {
         match *self {
             ObjectSafetyViolation::SizedSelf(_) => "it requires `Self: Sized`".into(),
             ObjectSafetyViolation::SupertraitSelf(ref spans) => {
-                if spans.iter().any(|sp| *sp != DUMMY_SP) {
+                if spans.iter().any(|sp| *sp != DUMMY_SPID) {
                     "it uses `Self` as a type parameter in this".into()
                 } else {
                     "it cannot use `Self` as a type parameter in a supertrait or `where`-clause"
@@ -599,7 +599,7 @@ impl ObjectSafetyViolation {
             ObjectSafetyViolation::Method(
                 name,
                 MethodViolationCode::ReferencesSelfInput(_),
-                DUMMY_SP,
+                DUMMY_SPID,
             ) => format!("method `{}` references the `Self` type in its parameters", name).into(),
             ObjectSafetyViolation::Method(name, MethodViolationCode::ReferencesSelfInput(_), _) => {
                 format!("method `{}` references the `Self` type in this parameter", name).into()
@@ -620,14 +620,14 @@ impl ObjectSafetyViolation {
             ObjectSafetyViolation::Method(name, MethodViolationCode::UndispatchableReceiver, _) => {
                 format!("method `{}`'s `self` parameter cannot be dispatched on", name).into()
             }
-            ObjectSafetyViolation::AssocConst(name, DUMMY_SP) => {
+            ObjectSafetyViolation::AssocConst(name, DUMMY_SPID) => {
                 format!("it contains associated `const` `{}`", name).into()
             }
             ObjectSafetyViolation::AssocConst(..) => "it contains this associated `const`".into(),
         }
     }
 
-    pub fn solution(&self) -> Option<(String, Option<(String, Span)>)> {
+    pub fn solution(&self) -> Option<(String, Option<(String, SpanId)>)> {
         Some(match *self {
             ObjectSafetyViolation::SizedSelf(_) | ObjectSafetyViolation::SupertraitSelf(_) => {
                 return None;
@@ -655,15 +655,15 @@ impl ObjectSafetyViolation {
         })
     }
 
-    pub fn spans(&self) -> SmallVec<[Span; 1]> {
-        // When `span` comes from a separate crate, it'll be `DUMMY_SP`. Treat it as `None` so
+    pub fn spans(&self) -> SmallVec<[SpanId; 1]> {
+        // When `span` comes from a separate crate, it'll be `DUMMY_SPID`. Treat it as `None` so
         // diagnostics use a `note` instead of a `span_label`.
         match self {
             ObjectSafetyViolation::SupertraitSelf(spans)
             | ObjectSafetyViolation::SizedSelf(spans) => spans.clone(),
             ObjectSafetyViolation::AssocConst(_, span)
             | ObjectSafetyViolation::Method(_, _, span)
-                if *span != DUMMY_SP =>
+                if *span != DUMMY_SPID =>
             {
                 smallvec![*span]
             }
@@ -676,7 +676,7 @@ impl ObjectSafetyViolation {
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, HashStable)]
 pub enum MethodViolationCode {
     /// e.g., `fn foo()`
-    StaticMethod(Option<(&'static str, Span)>),
+    StaticMethod(Option<(&'static str, SpanId)>),
 
     /// e.g., `fn foo(&self, x: Self)`
     ReferencesSelfInput(usize),

src/librustc_middle/ty/codec.rs

@@ -14,7 +14,7 @@ use crate::ty::{self, List, Ty, TyCtxt};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::{CrateNum, DefId};
 use rustc_serialize::{opaque, Decodable, Decoder, Encodable, Encoder};
-use rustc_span::Span;
+use rustc_span::SpanId;
 use std::hash::Hash;
 use std::intrinsics;
 
@@ -93,7 +93,7 @@ where
 
 pub fn encode_spanned_predicates<'tcx, E, C>(
     encoder: &mut E,
-    predicates: &'tcx [(ty::Predicate<'tcx>, Span)],
+    predicates: &'tcx [(ty::Predicate<'tcx>, SpanId)],
     cache: C,
 ) -> Result<(), E::Error>
 where
@@ -187,7 +187,7 @@ where
 #[inline]
 pub fn decode_spanned_predicates<D>(
     decoder: &mut D,
-) -> Result<&'tcx [(ty::Predicate<'tcx>, Span)], D::Error>
+) -> Result<&'tcx [(ty::Predicate<'tcx>, SpanId)], D::Error>
 where
     D: TyDecoder<'tcx>,
 {
@@ -356,7 +356,7 @@ macro_rules! implement_ty_decoder {
             use $crate::ty::subst::SubstsRef;
             use rustc_hir::def_id::{CrateNum};
 
-            use rustc_span::Span;
+            use rustc_span::SpanId;
 
             use super::$DecoderName;
 
@@ -413,10 +413,10 @@ macro_rules! implement_ty_decoder {
                 }
             }
 
-            impl<$($typaram),*> SpecializedDecoder<&'tcx [(ty::Predicate<'tcx>, Span)]>
+            impl<$($typaram),*> SpecializedDecoder<&'tcx [(ty::Predicate<'tcx>, SpanId)]>
             for $DecoderName<$($typaram),*> {
                 fn specialized_decode(&mut self)
-                                      -> Result<&'tcx [(ty::Predicate<'tcx>, Span)], Self::Error> {
+                                      -> Result<&'tcx [(ty::Predicate<'tcx>, SpanId)], Self::Error> {
                     decode_spanned_predicates(self)
                 }
             }

src/librustc_middle/ty/context.rs

@@ -942,7 +942,7 @@ pub struct GlobalCtxt<'tcx> {
     pub queries: query::Queries<'tcx>,
 
     maybe_unused_trait_imports: FxHashSet<LocalDefId>,
-    maybe_unused_extern_crates: Vec<(DefId, Span)>,
+    maybe_unused_extern_crates: Vec<(DefId, SpanId)>,
     /// A map of glob use to a set of names it actually imports. Currently only
     /// used in save-analysis.
     glob_map: FxHashMap<LocalDefId, FxHashSet<Symbol>>,
@@ -1158,7 +1158,7 @@ impl<'tcx> TyCtxt<'tcx> {
             maybe_unused_extern_crates: resolutions
                 .maybe_unused_extern_crates
                 .into_iter()
-                .map(|(id, sp)| (definitions.local_def_id(id).to_def_id(), sp))
+                .map(|(id, sp)| (definitions.local_def_id(id).to_def_id(), sp.into()))
                 .collect(),
             glob_map: resolutions
                 .glob_map

src/librustc_middle/ty/mod.rs

@@ -39,7 +39,7 @@ use rustc_serialize::{self, Encodable, Encoder};
 use rustc_session::DataTypeKind;
 use rustc_span::hygiene::ExpnId;
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
-use rustc_span::Span;
+use rustc_span::{Span, SpanId};
 use rustc_target::abi::{Align, VariantIdx};
 
 use std::cell::RefCell;
@@ -1082,7 +1082,7 @@ impl<'tcx> Generics {
 #[derive(Copy, Clone, Default, Debug, RustcEncodable, RustcDecodable, HashStable)]
 pub struct GenericPredicates<'tcx> {
     pub parent: Option<DefId>,
-    pub predicates: &'tcx [(Predicate<'tcx>, Span)],
+    pub predicates: &'tcx [(Predicate<'tcx>, SpanId)],
 }
 
 impl<'tcx> GenericPredicates<'tcx> {
@@ -1206,7 +1206,7 @@ pub struct CratePredicatesMap<'tcx> {
     /// For each struct with outlive bounds, maps to a vector of the
     /// predicate of its outlive bounds. If an item has no outlives
     /// bounds, it will have no entry.
-    pub predicates: FxHashMap<DefId, &'tcx [(ty::Predicate<'tcx>, Span)]>,
+    pub predicates: FxHashMap<DefId, &'tcx [(ty::Predicate<'tcx>, SpanId)]>,
 }
 
 impl<'tcx> AsRef<Predicate<'tcx>> for Predicate<'tcx> {
@@ -1529,7 +1529,7 @@ impl<'tcx> Predicate<'tcx> {
 #[derive(Clone, Debug, TypeFoldable)]
 pub struct InstantiatedPredicates<'tcx> {
     pub predicates: Vec<Predicate<'tcx>>,
-    pub spans: Vec<Span>,
+    pub spans: Vec<SpanId>,
 }
 
 impl<'tcx> InstantiatedPredicates<'tcx> {