Use Spanned not semi-traversable Span tuples

Author: eggyal

Cargo.lock

@@ -5301,6 +5301,7 @@ dependencies = [
  "rustc_index",
  "rustc_macros",
  "rustc_serialize",
+ "rustc_type_ir",
  "scoped-tls",
  "sha1",
  "sha2",

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -671,8 +671,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         let tcx = self.infcx.tcx;
 
         // Find out if the predicates show that the type is a Fn or FnMut
-        let find_fn_kind_from_did = |(pred, _): (ty::Predicate<'tcx>, _)| {
-            if let ty::PredicateKind::Clause(ty::Clause::Trait(pred)) = pred.kind().skip_binder()
+        let find_fn_kind_from_did = |pred: ty::Spanned<ty::Predicate<'tcx>>| {
+            if let ty::PredicateKind::Clause(ty::Clause::Trait(pred)) = pred.node.kind().skip_binder()
                 && pred.self_ty() == ty
             {
                 if Some(pred.def_id()) == tcx.lang_items().fn_trait() {

compiler/rustc_borrowck/src/diagnostics/move_errors.rs

@@ -103,7 +103,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                         // opt_match_place is None for let [mut] x = ... statements,
                         // whether or not the right-hand side is a place expression
                         if let LocalInfo::User(BindingForm::Var(VarBindingForm {
-                            opt_match_place: Some((opt_match_place, match_span)),
+                            opt_match_place:
+                                Some(ty::Spanned { node: opt_match_place, span: match_span }),
                             binding_mode: _,
                             opt_ty_info: _,
                             pat_span: _,

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -107,10 +107,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         instantiated_predicates: ty::InstantiatedPredicates<'tcx>,
         locations: Locations,
     ) {
-        for (predicate, span) in instantiated_predicates {
-            debug!(?predicate);
-            let category = ConstraintCategory::Predicate(span);
-            let predicate = self.normalize_with_category(predicate, locations, category);
+        for predicate in instantiated_predicates {
+            debug!(?predicate.node);
+            let category = ConstraintCategory::Predicate(predicate.span);
+            let predicate = self.normalize_with_category(predicate.node, locations, category);
             self.prove_predicate(predicate, locations, category);
         }
     }

compiler/rustc_codegen_cranelift/src/common.rs

@@ -451,13 +451,13 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> {
         loop {
             let scope_data = &self.mir.source_scopes[source_info.scope];
 
-            if let Some((callee, callsite_span)) = scope_data.inlined {
+            if let Some(callee) = scope_data.inlined {
                 // Stop inside the most nested non-`#[track_caller]` function,
                 // before ever reaching its caller (which is irrelevant).
-                if !callee.def.requires_caller_location(self.tcx) {
+                if !callee.node.def.requires_caller_location(self.tcx) {
                     return span_to_caller_location(self, source_info.span);
                 }
-                source_info.span = callsite_span;
+                source_info.span = callee.span;
             }
 
             // Skip past all of the parents with `inlined: None`.

compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs

@@ -87,13 +87,13 @@ fn make_mir_scope<'ll, 'tcx>(
     let file_metadata = file_metadata(cx, &loc.file);
 
     let dbg_scope = match scope_data.inlined {
-        Some((callee, _)) => {
+        Some(callee) => {
             // FIXME(eddyb) this would be `self.monomorphize(&callee)`
             // if this is moved to `rustc_codegen_ssa::mir::debuginfo`.
             let callee = cx.tcx.subst_and_normalize_erasing_regions(
                 instance.substs,
                 ty::ParamEnv::reveal_all(),
-                callee,
+                callee.node,
             );
             let callee_fn_abi = cx.fn_abi_of_instance(callee, ty::List::empty());
             cx.dbg_scope_fn(callee, callee_fn_abi, None)
@@ -109,11 +109,11 @@ fn make_mir_scope<'ll, 'tcx>(
         },
     };
 
-    let inlined_at = scope_data.inlined.map(|(_, callsite_span)| {
+    let inlined_at = scope_data.inlined.map(|callee| {
         // FIXME(eddyb) this doesn't account for the macro-related
         // `Span` fixups that `rustc_codegen_ssa::mir::debuginfo` does.
-        let callsite_scope = parent_scope.adjust_dbg_scope_for_span(cx, callsite_span);
-        cx.dbg_loc(callsite_scope, parent_scope.inlined_at, callsite_span)
+        let callsite_scope = parent_scope.adjust_dbg_scope_for_span(cx, callee.span);
+        cx.dbg_loc(callsite_scope, parent_scope.inlined_at, callee.span)
     });
 
     debug_context.scopes[scope] = DebugScope {

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1497,13 +1497,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         loop {
             let scope_data = &self.mir.source_scopes[source_info.scope];
 
-            if let Some((callee, callsite_span)) = scope_data.inlined {
+            if let Some(callee) = scope_data.inlined {
                 // Stop inside the most nested non-`#[track_caller]` function,
                 // before ever reaching its caller (which is irrelevant).
-                if !callee.def.requires_caller_location(tcx) {
+                if !callee.node.def.requires_caller_location(tcx) {
                     return span_to_caller_location(source_info.span);
                 }
-                source_info.span = callsite_span;
+                source_info.span = callee.span;
             }
 
             // Skip past all of the parents with `inlined: None`.

compiler/rustc_const_eval/src/interpret/intrinsics/caller_location.rs

@@ -44,13 +44,13 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             loop {
                 let scope_data = &frame.body.source_scopes[source_info.scope];
 
-                if let Some((callee, callsite_span)) = scope_data.inlined {
+                if let Some(callee) = scope_data.inlined {
                     // Stop inside the most nested non-`#[track_caller]` function,
                     // before ever reaching its caller (which is irrelevant).
-                    if !callee.def.requires_caller_location(*self.tcx) {
+                    if !callee.node.def.requires_caller_location(*self.tcx) {
                         return source_info.span;
                     }
-                    source_info.span = callsite_span;
+                    source_info.span = callee.span;
                 }
 
                 // Skip past all of the parents with `inlined: None`.

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -1314,20 +1314,20 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
         let mut trait_bounds = vec![];
         let mut projection_bounds = vec![];
-        for (pred, span) in bounds.predicates() {
-            let bound_pred = pred.kind();
+        for pred in bounds.predicates() {
+            let bound_pred = pred.node.kind();
             match bound_pred.skip_binder() {
                 ty::PredicateKind::Clause(clause) => match clause {
                     ty::Clause::Trait(trait_pred) => {
                         assert_eq!(trait_pred.polarity, ty::ImplPolarity::Positive);
                         trait_bounds.push((
                             bound_pred.rebind(trait_pred.trait_ref),
-                            span,
+                            pred.span,
                             trait_pred.constness,
                         ));
                     }
                     ty::Clause::Projection(proj) => {
-                        projection_bounds.push((bound_pred.rebind(proj), span));
+                        projection_bounds.push((bound_pred.rebind(proj), pred.span));
                     }
                     ty::Clause::TypeOutlives(_) => {
                         // Do nothing, we deal with regions separately
@@ -1784,8 +1784,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             || {
                 traits::transitive_bounds_that_define_assoc_type(
                     tcx,
-                    predicates.iter().filter_map(|(p, _)| {
-                        Some(p.to_opt_poly_trait_pred()?.map_bound(|t| t.trait_ref))
+                    predicates.iter().filter_map(|p| {
+                        Some(p.node.to_opt_poly_trait_pred()?.map_bound(|t| t.trait_ref))
                     }),
                     assoc_name,
                 )

compiler/rustc_hir_analysis/src/bounds.rs

@@ -23,7 +23,7 @@ use rustc_span::Span;
 /// include the self type (e.g., `trait_bounds`) but in others we do not
 #[derive(Default, PartialEq, Eq, Clone, Debug)]
 pub struct Bounds<'tcx> {
-    pub predicates: Vec<(ty::Predicate<'tcx>, Span)>,
+    pub predicates: Vec<ty::Spanned<ty::Predicate<'tcx>>>,
 }
 
 impl<'tcx> Bounds<'tcx> {
@@ -33,7 +33,7 @@ impl<'tcx> Bounds<'tcx> {
         region: ty::PolyTypeOutlivesPredicate<'tcx>,
         span: Span,
     ) {
-        self.predicates.push((region.to_predicate(tcx), span));
+        self.predicates.push(ty::Spanned { node: region.to_predicate(tcx), span });
     }
 
     pub fn push_trait_bound(
@@ -43,7 +43,10 @@ impl<'tcx> Bounds<'tcx> {
         span: Span,
         constness: ty::BoundConstness,
     ) {
-        self.predicates.push((trait_ref.with_constness(constness).to_predicate(tcx), span));
+        self.predicates.push(ty::Spanned {
+            node: trait_ref.with_constness(constness).to_predicate(tcx),
+            span,
+        });
     }
 
     pub fn push_projection_bound(
@@ -52,17 +55,18 @@ impl<'tcx> Bounds<'tcx> {
         projection: ty::PolyProjectionPredicate<'tcx>,
         span: Span,
     ) {
-        self.predicates.push((projection.to_predicate(tcx), span));
+        self.predicates.push(ty::Spanned { node: projection.to_predicate(tcx), span });
     }
 
     pub fn push_sized(&mut self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) {
         let sized_def_id = tcx.require_lang_item(LangItem::Sized, Some(span));
         let trait_ref = ty::Binder::dummy(tcx.mk_trait_ref(sized_def_id, [ty]));
         // Preferrable to put this obligation first, since we report better errors for sized ambiguity.
-        self.predicates.insert(0, (trait_ref.without_const().to_predicate(tcx), span));
+        self.predicates
+            .insert(0, ty::Spanned { node: trait_ref.without_const().to_predicate(tcx), span });
     }
 
-    pub fn predicates(&self) -> impl Iterator<Item = (ty::Predicate<'tcx>, Span)> + '_ {
+    pub fn predicates(&self) -> impl Iterator<Item = ty::Spanned<ty::Predicate<'tcx>>> + '_ {
         self.predicates.iter().cloned()
     }
 }

compiler/rustc_hir_analysis/src/check/check.rs

@@ -320,7 +320,7 @@ pub(super) fn check_opaque_for_inheriting_lifetimes(
         let prohibit_opaque = tcx
             .explicit_item_bounds(def_id)
             .iter()
-            .try_for_each(|(predicate, _)| predicate.visit_with(&mut visitor));
+            .try_for_each(|predicate| predicate.node.visit_with(&mut visitor));
 
         if let Some(ty) = prohibit_opaque.break_value() {
             visitor.visit_item(&item);

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -187,7 +187,7 @@ fn compare_method_predicate_entailment<'tcx>(
     hybrid_preds.predicates.extend(
         trait_m_predicates
             .instantiate_own(tcx, trait_to_placeholder_substs)
-            .map(|(predicate, _)| predicate),
+            .map(|predicate| predicate.node),
     );
 
     // Construct trait parameter environment and then shift it into the placeholder viewpoint.
@@ -207,7 +207,7 @@ fn compare_method_predicate_entailment<'tcx>(
     debug!("compare_impl_method: caller_bounds={:?}", param_env.caller_bounds());
 
     let impl_m_own_bounds = impl_m_predicates.instantiate_own(tcx, impl_to_placeholder_substs);
-    for (predicate, span) in impl_m_own_bounds {
+    for ty::Spanned { node: predicate, span } in impl_m_own_bounds {
         let normalize_cause = traits::ObligationCause::misc(span, impl_m_def_id);
         let predicate = ocx.normalize(&normalize_cause, param_env, predicate);
 
@@ -846,7 +846,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ImplTraitInTraitCollector<'_, 'tcx> {
             });
             self.types.insert(proj.def_id, (infer_ty, proj.substs));
             // Recurse into bounds
-            for (pred, pred_span) in self.interner().bound_explicit_item_bounds(proj.def_id).subst_iter_copied(self.interner(), proj.substs) {
+            for ty::Spanned { node: pred, span: pred_span } in self.interner().bound_explicit_item_bounds(proj.def_id).subst_iter_copied(self.interner(), proj.substs) {
                 let pred = pred.fold_with(self);
                 let pred = self.ocx.normalize(
                     &ObligationCause::misc(self.span, self.body_id),
@@ -1804,7 +1804,7 @@ fn compare_type_predicate_entailment<'tcx>(
     hybrid_preds.predicates.extend(
         trait_ty_predicates
             .instantiate_own(tcx, trait_to_impl_substs)
-            .map(|(predicate, _)| predicate),
+            .map(|predicate| predicate.node),
     );
 
     debug!("compare_type_predicate_entailment: bounds={:?}", hybrid_preds);
@@ -1822,7 +1822,7 @@ fn compare_type_predicate_entailment<'tcx>(
 
     debug!("compare_type_predicate_entailment: caller_bounds={:?}", param_env.caller_bounds());
 
-    for (predicate, span) in impl_ty_own_bounds {
+    for ty::Spanned { node: predicate, span } in impl_ty_own_bounds {
         let cause = ObligationCause::misc(span, impl_ty_def_id);
         let predicate = ocx.normalize(&cause, param_env, predicate);
 
@@ -2043,9 +2043,14 @@ pub(super) fn check_type_bounds<'tcx>(
     let obligations = tcx
         .bound_explicit_item_bounds(trait_ty.def_id)
         .subst_iter_copied(tcx, rebased_substs)
-        .map(|(concrete_ty_bound, span)| {
-            debug!("check_type_bounds: concrete_ty_bound = {:?}", concrete_ty_bound);
-            traits::Obligation::new(tcx, mk_cause(span), param_env, concrete_ty_bound)
+        .map(|concrete_ty_bound| {
+            debug!("check_type_bounds: concrete_ty_bound = {:?}", concrete_ty_bound.node);
+            traits::Obligation::new(
+                tcx,
+                mk_cause(concrete_ty_bound.span),
+                param_env,
+                concrete_ty_bound.node,
+            )
         })
         .collect();
     debug!("check_type_bounds: item_bounds={:?}", obligations);

compiler/rustc_hir_analysis/src/check/dropck.rs

@@ -155,7 +155,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
     // just to look for all the predicates directly.
 
     assert_eq!(dtor_predicates.parent, None);
-    for &(predicate, predicate_sp) in dtor_predicates.predicates {
+    for &ty::Spanned { node: predicate, span: predicate_sp } in dtor_predicates.predicates {
         // (We do not need to worry about deep analysis of type
         // expressions etc because the Drop impls are already forced
         // to take on a structure that is roughly an alpha-renaming of

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -302,9 +302,9 @@ fn bounds_from_generic_predicates<'tcx>(
 ) -> (String, String) {
     let mut types: FxHashMap<Ty<'tcx>, Vec<DefId>> = FxHashMap::default();
     let mut projections = vec![];
-    for (predicate, _) in predicates.predicates {
-        debug!("predicate {:?}", predicate);
-        let bound_predicate = predicate.kind();
+    for predicate in predicates.predicates {
+        debug!("predicate {:?}", predicate.node);
+        let bound_predicate = predicate.node.kind();
         match bound_predicate.skip_binder() {
             ty::PredicateKind::Clause(ty::Clause::Trait(trait_predicate)) => {
                 let entry = types.entry(trait_predicate.self_ty()).or_default();

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1134,14 +1134,14 @@ fn check_associated_type_bounds(wfcx: &WfCheckingCtxt<'_, '_>, item: ty::AssocIt
     let bounds = wfcx.tcx().explicit_item_bounds(item.def_id);
 
     debug!("check_associated_type_bounds: bounds={:?}", bounds);
-    let wf_obligations = bounds.iter().flat_map(|&(bound, bound_span)| {
-        let normalized_bound = wfcx.normalize(span, None, bound);
+    let wf_obligations = bounds.iter().flat_map(|&bound| {
+        let normalized_bound = wfcx.normalize(span, None, bound.node);
         traits::wf::predicate_obligations(
             wfcx.infcx,
             wfcx.param_env,
             wfcx.body_def_id,
             normalized_bound,
-            bound_span,
+            bound.span,
         )
     });
 
@@ -1377,7 +1377,7 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
     let default_obligations = predicates
         .predicates
         .iter()
-        .flat_map(|&(pred, sp)| {
+        .flat_map(|&pred| {
             #[derive(Default)]
             struct CountParams {
                 params: FxHashSet<u32>,
@@ -1404,18 +1404,18 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
                 }
             }
             let mut param_count = CountParams::default();
-            let has_region = pred.visit_with(&mut param_count).is_break();
-            let substituted_pred = ty::EarlyBinder(pred).subst(tcx, substs);
+            let has_region = pred.node.visit_with(&mut param_count).is_break();
+            let substituted_pred = ty::EarlyBinder(pred.node).subst(tcx, substs);
             // Don't check non-defaulted params, dependent defaults (including lifetimes)
             // or preds with multiple params.
             if substituted_pred.has_non_region_param() || param_count.params.len() > 1 || has_region
             {
                 None
-            } else if predicates.predicates.iter().any(|&(p, _)| p == substituted_pred) {
+            } else if predicates.predicates.iter().any(|&p| p.node == substituted_pred) {
                 // Avoid duplication of predicates that contain no parameters, for example.
                 None
             } else {
-                Some((substituted_pred, sp))
+                Some((substituted_pred, pred.span))
             }
         })
         .map(|(pred, sp)| {
@@ -1443,13 +1443,13 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
 
     debug!(?predicates.predicates);
     assert_eq!(predicates.predicates.len(), predicates.spans.len());
-    let wf_obligations = predicates.into_iter().flat_map(|(p, sp)| {
+    let wf_obligations = predicates.into_iter().flat_map(|p| {
         traits::wf::predicate_obligations(
             infcx,
             wfcx.param_env.without_const(),
             wfcx.body_def_id,
-            p,
-            sp,
+            p.node,
+            p.span,
         )
     });
     let obligations: Vec<_> = wf_obligations.chain(default_obligations).collect();
@@ -1566,7 +1566,7 @@ fn check_return_position_impl_trait_in_trait_bounds<'tcx>(
             {
                 let span = tcx.def_span(opaque_ty.def_id);
                 let bounds = wfcx.tcx().explicit_item_bounds(opaque_ty.def_id);
-                let wf_obligations = bounds.iter().flat_map(|&(bound, bound_span)| {
+                let wf_obligations = bounds.iter().flat_map(|&ty::Spanned { node: bound, span: bound_span }| {
                     let bound = ty::EarlyBinder(bound).subst(tcx, opaque_ty.substs);
                     let normalized_bound = wfcx.normalize(span, None, bound);
                     traits::wf::predicate_obligations(

compiler/rustc_hir_analysis/src/collect.rs

@@ -1448,8 +1448,9 @@ fn predicates_defined_on(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicate
             "predicates_defined_on: inferred_outlives_of({:?}) = {:?}",
             def_id, inferred_outlives,
         );
-        let inferred_outlives_iter =
-            inferred_outlives.iter().map(|(clause, span)| ((*clause).to_predicate(tcx), *span));
+        let inferred_outlives_iter = inferred_outlives
+            .iter()
+            .map(|(clause, span)| ty::Spanned { node: (*clause).to_predicate(tcx), span: *span });
         if result.predicates.is_empty() {
             result.predicates = tcx.arena.alloc_from_iter(inferred_outlives_iter);
         } else {