Wrap def_span query to return a SpanId.

Author: cjgillot

src/librustc_codegen_llvm/consts.rs

@@ -260,7 +260,7 @@ impl CodegenCx<'ll, 'tcx> {
             debug!("get_static: sym={} item_attr={:?}", sym, self.tcx.item_attrs(def_id));
 
             let attrs = self.tcx.codegen_fn_attrs(def_id);
-            let span = self.tcx.def_span(def_id);
+            let span = self.tcx.real_def_span(def_id);
             let g = check_and_apply_linkage(&self, &attrs, ty, sym, span);
 
             // Thread-local statics in some other crate need to *always* be linked

src/librustc_codegen_llvm/debuginfo/metadata.rs

@@ -2313,7 +2313,7 @@ pub fn create_global_var_metadata(cx: &CodegenCx<'ll, '_>, def_id: DefId, global
     // We may want to remove the namespace scope if we're in an extern block (see
     // https://github.com/rust-lang/rust/pull/46457#issuecomment-351750952).
     let var_scope = get_namespace_for_item(cx, def_id);
-    let span = tcx.def_span(def_id);
+    let span = tcx.real_def_span(def_id);
 
     let (file_metadata, line_number) = if !span.is_dummy() {
         let loc = cx.lookup_debug_loc(span.lo());

src/librustc_codegen_ssa/base.rs

@@ -45,7 +45,7 @@ use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
 use rustc_session::cgu_reuse_tracker::CguReuse;
 use rustc_session::config::{self, EntryFnType};
 use rustc_session::Session;
-use rustc_span::Span;
+use rustc_span::SpanId;
 use rustc_symbol_mangling::test as symbol_names_test;
 use rustc_target::abi::{Abi, Align, LayoutOf, Scalar, VariantIdx};
 
@@ -414,7 +414,7 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
     fn create_entry_fn<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         cx: &'a Bx::CodegenCx,
-        sp: Span,
+        sp: SpanId,
         rust_main: Bx::Value,
         rust_main_def_id: LocalDefId,
         use_start_lang_item: bool,

src/librustc_infer/infer/error_reporting/mod.rs

@@ -1467,7 +1467,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         impl<'tcx> ty::fold::TypeVisitor<'tcx> for OpaqueTypesVisitor<'tcx> {
             fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
                 if let Some((kind, def_id)) = TyCategory::from_ty(t) {
-                    let span = self.tcx.def_span(def_id);
+                    let span = self.tcx.real_def_span(def_id);
                     // Avoid cluttering the output when the "found" and error span overlap:
                     //
                     // error[E0308]: mismatched types
@@ -1543,7 +1543,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                             self.tcx
                                 .sess
                                 .source_map()
-                                .mk_substr_filename(self.tcx.def_span(*def_id)),
+                                .mk_substr_filename(self.tcx.real_def_span(*def_id)),
                         ),
                         (true, _) => format!(" ({})", ty.sort_string(self.tcx)),
                         (false, _) => "".to_string(),

src/librustc_infer/infer/error_reporting/nice_region_error/trait_impl_difference.rs

@@ -6,7 +6,7 @@ use crate::infer::{Subtype, ValuePairs};
 use crate::traits::ObligationCauseCode::CompareImplMethodObligation;
 use rustc_errors::ErrorReported;
 use rustc_middle::ty::Ty;
-use rustc_span::Span;
+use rustc_span::{Span, SpanId};
 
 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
     /// Print the error message for lifetime errors when the `impl` doesn't conform to the `trait`.
@@ -47,7 +47,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
         None
     }
 
-    fn emit_err(&self, sp: Span, expected: Ty<'tcx>, found: Ty<'tcx>, impl_sp: Span) {
+    fn emit_err(&self, sp: Span, expected: Ty<'tcx>, found: Ty<'tcx>, impl_sp: SpanId) {
         let mut err = self
             .tcx()
             .sess

src/librustc_infer/infer/lexical_region_resolve/mod.rs

@@ -664,7 +664,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
                 .iter()
                 .map(|&choice_region| var_data.normalize(self.tcx(), choice_region));
             if !choice_regions.clone().any(|choice_region| member_region == choice_region) {
-                let span = self.tcx().def_span(member_constraint.opaque_type_def_id);
+                let span = self.tcx().real_def_span(member_constraint.opaque_type_def_id);
                 errors.push(RegionResolutionError::MemberConstraintFailure {
                     span,
                     hidden_ty: member_constraint.hidden_ty,

src/librustc_infer/infer/mod.rs

@@ -33,7 +33,7 @@ use rustc_middle::ty::{self, GenericParamDefKind, InferConst, Ty, TyCtxt};
 use rustc_middle::ty::{ConstVid, FloatVid, IntVid, TyVid};
 use rustc_session::config::BorrowckMode;
 use rustc_span::symbol::Symbol;
-use rustc_span::Span;
+use rustc_span::{Span, SpanId};
 
 use std::cell::{Cell, Ref, RefCell};
 use std::collections::BTreeMap;
@@ -1579,7 +1579,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         def_id: DefId,
         substs: SubstsRef<'tcx>,
         promoted: Option<mir::Promoted>,
-        span: Option<Span>,
+        span: Option<SpanId>,
     ) -> ConstEvalResult<'tcx> {
         let mut original_values = OriginalQueryValues::default();
         let canonical = self.canonicalize_query(&(param_env, substs), &mut original_values);

src/librustc_interface/callbacks.rs

@@ -35,10 +35,10 @@ fn track_diagnostic(diagnostic: Diagnostic) -> RealDiagnostic {
                 let mut diagnostics = diagnostics.lock();
                 diagnostics.extend(Some(diagnostic.clone()));
             }
-            diagnostic.map_span(|s| match s {
-                rustc_span::SpanId::Span(s) => s,
-                rustc_span::SpanId::DefId(d) => icx.tcx.def_span(d),
-            })
+
+            // Ignore dependencies when reifying spans.
+            let icx = tls::ImplicitCtxt { task_deps: None, ..icx.clone() };
+            tls::enter_context(&icx, |icx| diagnostic.map_span(|s| icx.tcx.reify_span(s)))
         } else {
             diagnostic.map_span(|s| match s {
                 rustc_span::SpanId::Span(s) => s,

src/librustc_lint/builtin.rs

@@ -1977,7 +1977,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidValue {
                                         if span.is_none() {
                                             // Point to this field, should be helpful for figuring
                                             // out where the source of the error is.
-                                            let span = tcx.def_span(field.did);
+                                            let span = tcx.real_def_span(field.did);
                                             write!(
                                                 &mut msg,
                                                 " (in this {} field)",

src/librustc_macros/src/query.rs

@@ -496,7 +496,7 @@ pub fn rustc_queries(input: TokenStream) -> TokenStream {
                             force_query::<crate::ty::query::queries::#name<'_>, _>(
                                 $tcx,
                                 key,
-                                DUMMY_SP,
+                                DUMMY_SPID,
                                 *$dep_node
                             );
                             return true;