Deduplicate errors that come from places like normalization, sized

compiler-errors · compiler-errors · commit c0c6603c7928 · 2022-08-21T02:35:11.000Z
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
@@ -15,6 +15,7 @@ use crate::check::{
 use crate::structured_errors::StructuredDiagnostic;
 
 use rustc_ast as ast;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{pluralize, Applicability, Diagnostic, DiagnosticId, MultiSpan};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind, Res};
@@ -1612,24 +1613,52 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         &self,
         errors: &mut Vec<traits::FulfillmentError<'tcx>>,
     ) {
+        let mut remap_cause = FxHashSet::default();
+        let mut not_adjusted = vec![];
+
         for error in errors {
-            self.adjust_fulfillment_error_for_expr_obligation(error);
+            let before_span = error.obligation.cause.span;
+            if self.adjust_fulfillment_error_for_expr_obligation(error) {
+                remap_cause.insert((
+                    before_span,
+                    error.obligation.predicate,
+                    error.obligation.cause.clone(),
+                ));
+                remap_cause.insert((
+                    before_span,
+                    error.obligation.predicate.without_const(self.tcx),
+                    error.obligation.cause.clone(),
+                ));
+            } else {
+                not_adjusted.push(error);
+            }
+        }
+
+        for error in not_adjusted {
+            for (span, predicate, cause) in &remap_cause {
+                if *predicate == error.obligation.predicate
+                    && span.contains(error.obligation.cause.span)
+                {
+                    error.obligation.cause = cause.clone();
+                    continue;
+                }
+            }
         }
     }
 
     fn adjust_fulfillment_error_for_expr_obligation(
         &self,
         error: &mut traits::FulfillmentError<'tcx>,
-    ) {
+    ) -> bool {
         let (traits::ExprItemObligation(def_id, hir_id, idx) | traits::ExprBindingObligation(def_id, _, hir_id, idx))
-            = *error.obligation.cause.code().peel_derives() else { return; };
+            = *error.obligation.cause.code().peel_derives() else { return false; };
 
         // Skip over mentioning async lang item
         if Some(def_id) == self.tcx.lang_items().from_generator_fn()
             && error.obligation.cause.span.desugaring_kind()
                 == Some(rustc_span::DesugaringKind::Async)
         {
-            return;
+            return false;
         }
         // Skip over closure arg mismatch, which has a better heuristic
         // to determine what span to point at.
@@ -1638,11 +1667,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         ) = error.code
             && let ty::Closure(..) | ty::Generator(..) = expected.skip_binder().self_ty().kind()
         {
-            return;
+            return false;
         }
 
         let Some(unsubstituted_pred) =
-            self.tcx.predicates_of(def_id).instantiate_identity(self.tcx).predicates.into_iter().nth(idx) else { return; };
+            self.tcx.predicates_of(def_id).instantiate_identity(self.tcx).predicates.into_iter().nth(idx)
+            else { return false; };
 
         let generics = self.tcx.generics_of(def_id);
         let predicate_substs = match unsubstituted_pred.kind().skip_binder() {
@@ -1709,67 +1739,69 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 {
                     if let Some(param_to_point_at) = param_to_point_at
                         && self.point_at_args_if_possible(error, def_id, param_to_point_at, *call_hir_id, callee.span, args) {
-                        return;
+                        return true;
                     }
 
                     if let Some(fallback_param_to_point_at) = fallback_param_to_point_at
                         && self.point_at_args_if_possible(error, def_id, fallback_param_to_point_at, *call_hir_id, callee.span, args)
                     {
-                        return;
+                        return true;
                     }
 
                     if let Some(self_param_to_point_at) = self_param_to_point_at
                         && self.point_at_args_if_possible(error, def_id, self_param_to_point_at, *call_hir_id, callee.span, args)
                     {
-                        return;
+                        return true;
                     }
 
                     if let hir::QPath::Resolved(_, path) = qpath
                         && let Some(param_to_point_at) = param_to_point_at
                         && let Some(segment) = path.segments.last()
                         && self.point_at_generics_if_possible(error, def_id, param_to_point_at, segment)
                     {
-                        return;
+                        return true;
                     }
 
                     if let hir::QPath::TypeRelative(_, segment) = qpath
                         && let Some(param_to_point_at) = param_to_point_at
                         && self.point_at_generics_if_possible(error, def_id, param_to_point_at, segment)
                     {
-                        return;
+                        return true;
                     }
                 }
             }
             hir::Node::Expr(hir::Expr { kind: hir::ExprKind::MethodCall(segment, args, ..), .. }) => {
                 if let Some(param_to_point_at) = param_to_point_at
                     && self.point_at_args_if_possible(error, def_id, param_to_point_at, hir_id, segment.ident.span, args)
                 {
-                    return;
+                    return true;
                 }
 
                 if let Some(fallback_param_to_point_at) = fallback_param_to_point_at
                     && self.point_at_args_if_possible(error, def_id, fallback_param_to_point_at, hir_id, segment.ident.span, args)
                 {
-                    return;
+                    return true;
                 }
 
                 if let Some(self_param_to_point_at) = self_param_to_point_at
                     && self.point_at_args_if_possible(error, def_id, self_param_to_point_at, hir_id, segment.ident.span, args)
                 {
-                    return;
+                    return true;
                 }
 
                 if let Some(param_to_point_at) = param_to_point_at
                     && self.point_at_generics_if_possible(error, def_id, param_to_point_at, segment)
                 {
-                    return;
+                    return true;
                 }
             }
             hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Struct(..), .. }) => {
                 // fixme
             }
             _ => {}
         }
+
+        false
     }
 
     fn find_ambiguous_parameter_in<T: TypeVisitable<'tcx>>(
diff --git a/src/test/ui/iterators/issue-28098.stderr b/src/test/ui/iterators/issue-28098.stderr
@@ -8,14 +8,6 @@ LL |     let _ = Iterator::next(&mut ());
    |
    = help: the trait `Iterator` is not implemented for `()`
 
-error[E0277]: `()` is not an iterator
-  --> $DIR/issue-28098.rs:2:13
-   |
-LL |     let _ = Iterator::next(&mut ());
-   |             ^^^^^^^^^^^^^^ `()` is not an iterator
-   |
-   = help: the trait `Iterator` is not implemented for `()`
-
 error[E0277]: `bool` is not an iterator
   --> $DIR/issue-28098.rs:5:14
    |
@@ -35,14 +27,6 @@ LL |     let _ = Iterator::next(&mut ());
    |
    = help: the trait `Iterator` is not implemented for `()`
 
-error[E0277]: `()` is not an iterator
-  --> $DIR/issue-28098.rs:8:13
-   |
-LL |     let _ = Iterator::next(&mut ());
-   |             ^^^^^^^^^^^^^^ `()` is not an iterator
-   |
-   = help: the trait `Iterator` is not implemented for `()`
-
 error[E0277]: `()` is not an iterator
   --> $DIR/issue-28098.rs:17:28
    |
@@ -53,14 +37,6 @@ LL |     let _ = Iterator::next(&mut ());
    |
    = help: the trait `Iterator` is not implemented for `()`
 
-error[E0277]: `()` is not an iterator
-  --> $DIR/issue-28098.rs:17:13
-   |
-LL |     let _ = Iterator::next(&mut ());
-   |             ^^^^^^^^^^^^^^ `()` is not an iterator
-   |
-   = help: the trait `Iterator` is not implemented for `()`
-
 error[E0277]: `()` is not an iterator
   --> $DIR/issue-28098.rs:20:28
    |
@@ -71,14 +47,6 @@ LL |     let _ = Iterator::next(&mut ());
    |
    = help: the trait `Iterator` is not implemented for `()`
 
-error[E0277]: `()` is not an iterator
-  --> $DIR/issue-28098.rs:20:13
-   |
-LL |     let _ = Iterator::next(&mut ());
-   |             ^^^^^^^^^^^^^^ `()` is not an iterator
-   |
-   = help: the trait `Iterator` is not implemented for `()`
-
 error[E0277]: `bool` is not an iterator
   --> $DIR/issue-28098.rs:23:14
    |
@@ -88,6 +56,6 @@ LL |     for _ in false {}
    = help: the trait `Iterator` is not implemented for `bool`
    = note: required for `bool` to implement `IntoIterator`
 
-error: aborting due to 10 previous errors
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/on-unimplemented/multiple-impls.stderr b/src/test/ui/on-unimplemented/multiple-impls.stderr
@@ -11,17 +11,6 @@ LL |     Index::index(&[] as &[i32], 2u32);
              <[i32] as Index<Bar<usize>>>
              <[i32] as Index<Foo<usize>>>
 
-error[E0277]: the trait bound `[i32]: Index<u32>` is not satisfied
-  --> $DIR/multiple-impls.rs:33:5
-   |
-LL |     Index::index(&[] as &[i32], 2u32);
-   |     ^^^^^^^^^^^^ trait message
-   |
-   = help: the trait `Index<u32>` is not implemented for `[i32]`
-   = help: the following other types implement trait `Index<Idx>`:
-             <[i32] as Index<Bar<usize>>>
-             <[i32] as Index<Foo<usize>>>
-
 error[E0277]: the trait bound `[i32]: Index<Foo<u32>>` is not satisfied
   --> $DIR/multiple-impls.rs:35:33
    |
@@ -35,17 +24,6 @@ LL |     Index::index(&[] as &[i32], Foo(2u32));
              <[i32] as Index<Bar<usize>>>
              <[i32] as Index<Foo<usize>>>
 
-error[E0277]: the trait bound `[i32]: Index<Foo<u32>>` is not satisfied
-  --> $DIR/multiple-impls.rs:35:5
-   |
-LL |     Index::index(&[] as &[i32], Foo(2u32));
-   |     ^^^^^^^^^^^^ on impl for Foo
-   |
-   = help: the trait `Index<Foo<u32>>` is not implemented for `[i32]`
-   = help: the following other types implement trait `Index<Idx>`:
-             <[i32] as Index<Bar<usize>>>
-             <[i32] as Index<Foo<usize>>>
-
 error[E0277]: the trait bound `[i32]: Index<Bar<u32>>` is not satisfied
   --> $DIR/multiple-impls.rs:37:33
    |
@@ -59,17 +37,6 @@ LL |     Index::index(&[] as &[i32], Bar(2u32));
              <[i32] as Index<Bar<usize>>>
              <[i32] as Index<Foo<usize>>>
 
-error[E0277]: the trait bound `[i32]: Index<Bar<u32>>` is not satisfied
-  --> $DIR/multiple-impls.rs:37:5
-   |
-LL |     Index::index(&[] as &[i32], Bar(2u32));
-   |     ^^^^^^^^^^^^ on impl for Bar
-   |
-   = help: the trait `Index<Bar<u32>>` is not implemented for `[i32]`
-   = help: the following other types implement trait `Index<Idx>`:
-             <[i32] as Index<Bar<usize>>>
-             <[i32] as Index<Foo<usize>>>
-
-error: aborting due to 6 previous errors
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/on-unimplemented/on-impl.stderr b/src/test/ui/on-unimplemented/on-impl.stderr
@@ -9,15 +9,6 @@ LL |     Index::<u32>::index(&[1, 2, 3] as &[i32], 2u32);
    = help: the trait `Index<u32>` is not implemented for `[i32]`
    = help: the trait `Index<usize>` is implemented for `[i32]`
 
-error[E0277]: the trait bound `[i32]: Index<u32>` is not satisfied
-  --> $DIR/on-impl.rs:22:5
-   |
-LL |     Index::<u32>::index(&[1, 2, 3] as &[i32], 2u32);
-   |     ^^^^^^^^^^^^^^^^^^^ a usize is required to index into a slice
-   |
-   = help: the trait `Index<u32>` is not implemented for `[i32]`
-   = help: the trait `Index<usize>` is implemented for `[i32]`
-
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/str/str-idx.stderr b/src/test/ui/str/str-idx.stderr
@@ -28,17 +28,6 @@ note: required by a bound in `core::str::<impl str>::get`
 LL |     pub const fn get<I: ~const SliceIndex<str>>(&self, i: I) -> Option<&I::Output> {
    |                         ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `core::str::<impl str>::get`
 
-error[E0277]: the type `str` cannot be indexed by `{integer}`
-  --> $DIR/str-idx.rs:4:15
-   |
-LL |     let _ = s.get(4);
-   |               ^^^ string indices are ranges of `usize`
-   |
-   = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
-   = note: you can use `.chars().nth()` or `.bytes().nth()`
-           for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
-   = help: the trait `SliceIndex<[T]>` is implemented for `usize`
-
 error[E0277]: the type `str` cannot be indexed by `{integer}`
   --> $DIR/str-idx.rs:5:29
    |
@@ -57,17 +46,6 @@ note: required by a bound in `core::str::<impl str>::get_unchecked`
 LL |     pub const unsafe fn get_unchecked<I: ~const SliceIndex<str>>(&self, i: I) -> &I::Output {
    |                                          ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `core::str::<impl str>::get_unchecked`
 
-error[E0277]: the type `str` cannot be indexed by `{integer}`
-  --> $DIR/str-idx.rs:5:15
-   |
-LL |     let _ = s.get_unchecked(4);
-   |               ^^^^^^^^^^^^^ string indices are ranges of `usize`
-   |
-   = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
-   = note: you can use `.chars().nth()` or `.bytes().nth()`
-           for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
-   = help: the trait `SliceIndex<[T]>` is implemented for `usize`
-
 error[E0277]: the type `str` cannot be indexed by `char`
   --> $DIR/str-idx.rs:6:19
    |
@@ -77,6 +55,6 @@ LL |     let _: u8 = s['c'];
    = help: the trait `SliceIndex<str>` is not implemented for `char`
    = note: required for `str` to implement `Index<char>`
 
-error: aborting due to 6 previous errors
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/str/str-mut-idx.stderr b/src/test/ui/str/str-mut-idx.stderr
@@ -52,17 +52,6 @@ note: required by a bound in `core::str::<impl str>::get_mut`
 LL |     pub const fn get_mut<I: ~const SliceIndex<str>>(&mut self, i: I) -> Option<&mut I::Output> {
    |                             ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `core::str::<impl str>::get_mut`
 
-error[E0277]: the type `str` cannot be indexed by `{integer}`
-  --> $DIR/str-mut-idx.rs:9:7
-   |
-LL |     s.get_mut(1);
-   |       ^^^^^^^ string indices are ranges of `usize`
-   |
-   = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
-   = note: you can use `.chars().nth()` or `.bytes().nth()`
-           for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
-   = help: the trait `SliceIndex<[T]>` is implemented for `usize`
-
 error[E0277]: the type `str` cannot be indexed by `{integer}`
   --> $DIR/str-mut-idx.rs:11:25
    |
@@ -81,17 +70,6 @@ note: required by a bound in `core::str::<impl str>::get_unchecked_mut`
 LL |     pub const unsafe fn get_unchecked_mut<I: ~const SliceIndex<str>>(
    |                                              ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `core::str::<impl str>::get_unchecked_mut`
 
-error[E0277]: the type `str` cannot be indexed by `{integer}`
-  --> $DIR/str-mut-idx.rs:11:7
-   |
-LL |     s.get_unchecked_mut(1);
-   |       ^^^^^^^^^^^^^^^^^ string indices are ranges of `usize`
-   |
-   = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
-   = note: you can use `.chars().nth()` or `.bytes().nth()`
-           for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
-   = help: the trait `SliceIndex<[T]>` is implemented for `usize`
-
 error[E0277]: the type `str` cannot be indexed by `char`
   --> $DIR/str-mut-idx.rs:13:7
    |
@@ -101,6 +79,6 @@ LL |     s['c'];
    = help: the trait `SliceIndex<str>` is not implemented for `char`
    = note: required for `str` to implement `Index<char>`
 
-error: aborting due to 8 previous errors
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/suggestions/mut-borrow-needed-by-trait.stderr b/src/test/ui/suggestions/mut-borrow-needed-by-trait.stderr

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ use crate::check::{`
`15`	`15`	`use crate::structured_errors::StructuredDiagnostic;`
`16`	`16`
`17`	`17`	`use rustc_ast as ast;`
	`18`	`+use rustc_data_structures::fx::FxHashSet;`
`18`	`19`	`use rustc_errors::{pluralize, Applicability, Diagnostic, DiagnosticId, MultiSpan};`
`19`	`20`	`use rustc_hir as hir;`
`20`	`21`	`use rustc_hir::def::{CtorOf, DefKind, Res};`
`@@ -1612,24 +1613,52 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1612`	`1613`	`&self,`
`1613`	`1614`	`errors: &mut Vec<traits::FulfillmentError<'tcx>>,`
`1614`	`1615`	`) {`
	`1616`	`+ let mut remap_cause = FxHashSet::default();`
	`1617`	`+ let mut not_adjusted = vec![];`
	`1618`	`+`
`1615`	`1619`	`for error in errors {`
`1616`		`- self.adjust_fulfillment_error_for_expr_obligation(error);`
	`1620`	`+ let before_span = error.obligation.cause.span;`
	`1621`	`+ if self.adjust_fulfillment_error_for_expr_obligation(error) {`
	`1622`	`+ remap_cause.insert((`
	`1623`	`+ before_span,`
	`1624`	`+ error.obligation.predicate,`
	`1625`	`+ error.obligation.cause.clone(),`
	`1626`	`+ ));`
	`1627`	`+ remap_cause.insert((`
	`1628`	`+ before_span,`
	`1629`	`+ error.obligation.predicate.without_const(self.tcx),`
	`1630`	`+ error.obligation.cause.clone(),`
	`1631`	`+ ));`
	`1632`	`+ } else {`
	`1633`	`+ not_adjusted.push(error);`
	`1634`	`+ }`
	`1635`	`+ }`
	`1636`	`+`
	`1637`	`+ for error in not_adjusted {`
	`1638`	`+ for (span, predicate, cause) in &remap_cause {`
	`1639`	`+ if *predicate == error.obligation.predicate`
	`1640`	`+ && span.contains(error.obligation.cause.span)`
	`1641`	`+ {`
	`1642`	`+ error.obligation.cause = cause.clone();`
	`1643`	`+ continue;`
	`1644`	`+ }`
	`1645`	`+ }`
`1617`	`1646`	`}`
`1618`	`1647`	`}`
`1619`	`1648`
`1620`	`1649`	`fn adjust_fulfillment_error_for_expr_obligation(`
`1621`	`1650`	`&self,`
`1622`	`1651`	`error: &mut traits::FulfillmentError<'tcx>,`
`1623`		`- ) {`
	`1652`	`+ ) -> bool {`
`1624`	`1653`	`let (traits::ExprItemObligation(def_id, hir_id, idx) \| traits::ExprBindingObligation(def_id, _, hir_id, idx))`
`1625`		`- = *error.obligation.cause.code().peel_derives() else { return; };`
	`1654`	`+ = *error.obligation.cause.code().peel_derives() else { return false; };`
`1626`	`1655`
`1627`	`1656`	`// Skip over mentioning async lang item`
`1628`	`1657`	`if Some(def_id) == self.tcx.lang_items().from_generator_fn()`
`1629`	`1658`	`&& error.obligation.cause.span.desugaring_kind()`
`1630`	`1659`	`== Some(rustc_span::DesugaringKind::Async)`
`1631`	`1660`	`{`
`1632`		`- return;`
	`1661`	`+ return false;`
`1633`	`1662`	`}`
`1634`	`1663`	`// Skip over closure arg mismatch, which has a better heuristic`
`1635`	`1664`	`// to determine what span to point at.`
`@@ -1638,11 +1667,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1638`	`1667`	`) = error.code`
`1639`	`1668`	`&& let ty::Closure(..) \| ty::Generator(..) = expected.skip_binder().self_ty().kind()`
`1640`	`1669`	`{`
`1641`		`- return;`
	`1670`	`+ return false;`
`1642`	`1671`	`}`
`1643`	`1672`
`1644`	`1673`	`let Some(unsubstituted_pred) =`
`1645`		`- self.tcx.predicates_of(def_id).instantiate_identity(self.tcx).predicates.into_iter().nth(idx) else { return; };`
	`1674`	`+ self.tcx.predicates_of(def_id).instantiate_identity(self.tcx).predicates.into_iter().nth(idx)`
	`1675`	`+ else { return false; };`
`1646`	`1676`
`1647`	`1677`	`let generics = self.tcx.generics_of(def_id);`
`1648`	`1678`	`let predicate_substs = match unsubstituted_pred.kind().skip_binder() {`
`@@ -1709,67 +1739,69 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1709`	`1739`	`{`
`1710`	`1740`	`if let Some(param_to_point_at) = param_to_point_at`
`1711`	`1741`	`&& self.point_at_args_if_possible(error, def_id, param_to_point_at, *call_hir_id, callee.span, args) {`
`1712`		`- return;`
	`1742`	`+ return true;`
`1713`	`1743`	`}`
`1714`	`1744`
`1715`	`1745`	`if let Some(fallback_param_to_point_at) = fallback_param_to_point_at`
`1716`	`1746`	`&& self.point_at_args_if_possible(error, def_id, fallback_param_to_point_at, *call_hir_id, callee.span, args)`
`1717`	`1747`	`{`
`1718`		`- return;`
	`1748`	`+ return true;`
`1719`	`1749`	`}`
`1720`	`1750`
`1721`	`1751`	`if let Some(self_param_to_point_at) = self_param_to_point_at`
`1722`	`1752`	`&& self.point_at_args_if_possible(error, def_id, self_param_to_point_at, *call_hir_id, callee.span, args)`
`1723`	`1753`	`{`
`1724`		`- return;`
	`1754`	`+ return true;`
`1725`	`1755`	`}`
`1726`	`1756`
`1727`	`1757`	`if let hir::QPath::Resolved(_, path) = qpath`
`1728`	`1758`	`&& let Some(param_to_point_at) = param_to_point_at`
`1729`	`1759`	`&& let Some(segment) = path.segments.last()`
`1730`	`1760`	`&& self.point_at_generics_if_possible(error, def_id, param_to_point_at, segment)`
`1731`	`1761`	`{`
`1732`		`- return;`
	`1762`	`+ return true;`
`1733`	`1763`	`}`
`1734`	`1764`
`1735`	`1765`	`if let hir::QPath::TypeRelative(_, segment) = qpath`
`1736`	`1766`	`&& let Some(param_to_point_at) = param_to_point_at`
`1737`	`1767`	`&& self.point_at_generics_if_possible(error, def_id, param_to_point_at, segment)`
`1738`	`1768`	`{`
`1739`		`- return;`
	`1769`	`+ return true;`
`1740`	`1770`	`}`
`1741`	`1771`	`}`
`1742`	`1772`	`}`
`1743`	`1773`	`hir::Node::Expr(hir::Expr { kind: hir::ExprKind::MethodCall(segment, args, ..), .. }) => {`
`1744`	`1774`	`if let Some(param_to_point_at) = param_to_point_at`
`1745`	`1775`	`&& self.point_at_args_if_possible(error, def_id, param_to_point_at, hir_id, segment.ident.span, args)`
`1746`	`1776`	`{`
`1747`		`- return;`
	`1777`	`+ return true;`
`1748`	`1778`	`}`
`1749`	`1779`
`1750`	`1780`	`if let Some(fallback_param_to_point_at) = fallback_param_to_point_at`
`1751`	`1781`	`&& self.point_at_args_if_possible(error, def_id, fallback_param_to_point_at, hir_id, segment.ident.span, args)`
`1752`	`1782`	`{`
`1753`		`- return;`
	`1783`	`+ return true;`
`1754`	`1784`	`}`
`1755`	`1785`
`1756`	`1786`	`if let Some(self_param_to_point_at) = self_param_to_point_at`
`1757`	`1787`	`&& self.point_at_args_if_possible(error, def_id, self_param_to_point_at, hir_id, segment.ident.span, args)`
`1758`	`1788`	`{`
`1759`		`- return;`
	`1789`	`+ return true;`
`1760`	`1790`	`}`
`1761`	`1791`
`1762`	`1792`	`if let Some(param_to_point_at) = param_to_point_at`
`1763`	`1793`	`&& self.point_at_generics_if_possible(error, def_id, param_to_point_at, segment)`
`1764`	`1794`	`{`
`1765`		`- return;`
	`1795`	`+ return true;`
`1766`	`1796`	`}`
`1767`	`1797`	`}`
`1768`	`1798`	`hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Struct(..), .. }) => {`
`1769`	`1799`	`// fixme`
`1770`	`1800`	`}`
`1771`	`1801`	`_ => {}`
`1772`	`1802`	`}`
	`1803`	`+`
	`1804`	`+ false`
`1773`	`1805`	`}`
`1774`	`1806`
`1775`	`1807`	`fn find_ambiguous_parameter_in<T: TypeVisitable<'tcx>>(`