Centralize calculation of FullfillmentError span

Use a method for caulculating deduplication and presentation span.

Author: estebank

compiler/rustc_hir_typeck/src/coercion.rs

@@ -686,7 +686,12 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
 
                 // Object safety violations or miscellaneous.
                 Err(err) => {
-                    self.err_ctxt().report_selection_error(obligation.clone(), &obligation, &err);
+                    self.err_ctxt().report_selection_error(
+                        obligation.clone(),
+                        &obligation,
+                        &err,
+                        obligation.cause.span,
+                    );
                     // Treat this like an obligation and follow through
                     // with the unsizing - the lack of a coercion should
                     // be silent, as it causes a type mismatch later.

compiler/rustc_infer/src/traits/mod.rs

@@ -17,7 +17,7 @@ use rustc_middle::traits::query::NoSolution;
 use rustc_middle::traits::solve::Certainty;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::{self, Const, ToPredicate, Ty, TyCtxt};
-use rustc_span::Span;
+use rustc_span::{DesugaringKind, ExpnKind, Span};
 
 pub use self::ImplSource::*;
 pub use self::SelectionError::*;
@@ -206,6 +206,18 @@ impl<'tcx> FulfillmentError<'tcx> {
     ) -> FulfillmentError<'tcx> {
         FulfillmentError { obligation, code, root_obligation }
     }
+    pub fn span(&self) -> Span {
+        let mut span = self.obligation.cause.span;
+        // We want to ignore desugarings here: spans are equivalent even
+        // if one is the result of a desugaring and the other is not.
+        let expn_data = span.ctxt().outer_expn_data();
+        if let ExpnKind::Desugaring(desugaring) = expn_data.kind
+            && DesugaringKind::QuestionMark != desugaring
+        {
+            span = expn_data.call_site;
+        }
+        span
+    }
 }
 
 impl<'tcx> PolyTraitObligation<'tcx> {

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

@@ -45,7 +45,7 @@ use rustc_session::config::DumpSolverProofTree;
 use rustc_session::Limit;
 use rustc_span::def_id::LOCAL_CRATE;
 use rustc_span::symbol::sym;
-use rustc_span::{BytePos, ExpnKind, Span, Symbol, DUMMY_SP};
+use rustc_span::{BytePos, Span, Symbol, DUMMY_SP};
 use std::borrow::Cow;
 use std::fmt;
 use std::iter;
@@ -124,15 +124,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         });
 
         for (index, error) in errors.iter().enumerate() {
-            // We want to ignore desugarings here: spans are equivalent even
-            // if one is the result of a desugaring and the other is not.
-            let mut span = error.obligation.cause.span;
-            let expn_data = span.ctxt().outer_expn_data();
-            if let ExpnKind::Desugaring(_) = expn_data.kind {
-                span = expn_data.call_site;
-            }
-
-            error_map.entry(span).or_default().push(ErrorDescriptor {
+            error_map.entry(error.span()).or_default().push(ErrorDescriptor {
                 predicate: error.obligation.predicate,
                 index: Some(index),
             });
@@ -176,16 +168,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                 if !suppressed && error.obligation.cause.span.from_expansion() == from_expansion {
                     let guar = self.report_fulfillment_error(error);
                     reported = Some(guar);
-                    // We want to ignore desugarings here: spans are equivalent even
-                    // if one is the result of a desugaring and the other is not.
-                    let mut span = error.obligation.cause.span;
-                    let expn_data = span.ctxt().outer_expn_data();
-                    if let ExpnKind::Desugaring(_) = expn_data.kind {
-                        span = expn_data.call_site;
-                    }
                     self.reported_trait_errors
                         .borrow_mut()
-                        .entry(span)
+                        .entry(error.span())
                         .or_insert_with(|| (vec![], guar))
                         .0
                         .push(error.obligation.predicate);
@@ -362,6 +347,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         mut obligation: PredicateObligation<'tcx>,
         root_obligation: &PredicateObligation<'tcx>,
         error: &SelectionError<'tcx>,
+        mut span: Span,
     ) -> ErrorGuaranteed {
         let tcx = self.tcx;
 
@@ -371,8 +357,6 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             dump_proof_tree(root_obligation, self.infcx);
         }
 
-        let mut span = obligation.cause.span;
-
         let mut err = match *error {
             SelectionError::Unimplemented => {
                 // If this obligation was generated as a result of well-formedness checking, see if we
@@ -1504,6 +1488,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     error.obligation.clone(),
                     &error.root_obligation,
                     selection_error,
+                    error.span(),
                 ),
             FulfillmentErrorCode::ProjectionError(ref e) => {
                 self.report_projection_error(&error.obligation, e)

src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs

@@ -13,6 +13,7 @@ use rustc_errors::{Applicability, Diag};
 use rustc_hir::{BinOp, Block, Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
+use rustc_span::edition::Edition;
 use rustc_span::source_map::Spanned;
 use rustc_span::{sym, Span};
 
@@ -137,8 +138,7 @@ fn assert_len_expr<'hir>(
     if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr)
         && let ExprKind::Unary(UnOp::Not, condition) = &cond.kind
         && let ExprKind::Binary(bin_op, left, right) = &condition.kind
-
-        && let Some((cmp, asserted_len, slice_len)) = len_comparison(*bin_op, left, right)
+        && let Some((cmp, asserted_len, slice_len)) = len_comparison(bin_op, left, right)
         && let ExprKind::MethodCall(method, recv, ..) = &slice_len.kind
         && cx.typeck_results().expr_ty_adjusted(recv).peel_refs().is_slice()
         && method.ident.name == sym::len

tests/ui/coroutine/issue-88653.rs

@@ -9,8 +9,6 @@ fn foo(bar: bool) -> impl Coroutine<(bool,)> {
     //~^ ERROR: type mismatch in coroutine arguments [E0631]
     //~| NOTE: expected due to this
     //~| NOTE: expected coroutine signature `fn((bool,)) -> _`
-    //~| NOTE: in this expansion of desugaring of `impl Trait`
-    //~| NOTE: in this expansion of desugaring of `impl Trait`
     |bar| {
         //~^ NOTE: found signature defined here
         if bar {

tests/ui/for/for-c-in-str.rs

@@ -6,9 +6,6 @@ fn main() {
         //~| NOTE `&str` is not an iterator
         //~| HELP the trait `Iterator` is not implemented for `&str`
         //~| NOTE required for `&str` to implement `IntoIterator`
-        //~| NOTE in this expansion of desugaring of `for` loop
-        //~| NOTE in this expansion of desugaring of `for` loop
-        //~| NOTE in this expansion of desugaring of `for` loop
         println!();
     }
 }

tests/ui/iterators/float_iterator_hint.rs

@@ -4,10 +4,6 @@ fn main() {
     for i in 0.2 {
         //~^ ERROR `{float}` is not an iterator
         //~| `{float}` is not an iterator
-        //~| NOTE in this expansion of desugaring of `for` loop
-        //~| NOTE in this expansion of desugaring of `for` loop
-        //~| NOTE in this expansion of desugaring of `for` loop
-        //~| NOTE in this expansion of desugaring of `for` loop
         //~| NOTE if you want to iterate between `start` until a value `end`, use the exclusive range syntax `start..end` or the inclusive range syntax `start..=end`
         //~| NOTE required for `{float}` to implement `IntoIterator`
         println!();

tests/ui/lifetimes/issue-76168-hr-outlives-3.stderr

@@ -33,6 +33,7 @@ LL | | for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a
    | |__________________________________________________________________________^ expected an `FnOnce(&'a mut i32)` closure, found `i32`
    |
    = help: the trait `for<'a> FnOnce<(&'a mut i32,)>` is not implemented for `i32`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0277]: expected a `FnOnce(&'a mut i32)` closure, found `i32`
   --> $DIR/issue-76168-hr-outlives-3.rs:6:1