Walk through full path in point_at_path_if_possible

compiler-errors · compiler-errors · commit 055452864e7f · 2023-08-25T19:05:38.000Z
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
@@ -1,6 +1,6 @@
 use crate::FnCtxt;
 use rustc_hir as hir;
-use rustc_hir::def::Res;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_infer::{infer::type_variable::TypeVariableOriginKind, traits::ObligationCauseCode};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor};
@@ -133,15 +133,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         }
                     }
                 }
-                // Notably, we only point to params that are local to the
-                // item we're checking, since those are the ones we are able
-                // to look in the final `hir::PathSegment` for. Everything else
-                // would require a deeper search into the `qpath` than I think
-                // is worthwhile.
-                if let Some(param_to_point_at) = param_to_point_at
-                    && self.point_at_path_if_possible(error, def_id, param_to_point_at, qpath)
+
+                for param in [param_to_point_at, fallback_param_to_point_at, self_param_to_point_at]
+                    .into_iter()
+                    .flatten()
                 {
-                    return true;
+                    if self.point_at_path_if_possible(error, def_id, param, qpath) {
+                        return true;
+                    }
                 }
             }
             hir::ExprKind::MethodCall(segment, receiver, args, ..) => {
@@ -168,10 +167,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
             }
             hir::ExprKind::Struct(qpath, fields, ..) => {
-                if let Res::Def(
-                    hir::def::DefKind::Struct | hir::def::DefKind::Variant,
-                    variant_def_id,
-                ) = self.typeck_results.borrow().qpath_res(qpath, hir_id)
+                if let Res::Def(DefKind::Struct | DefKind::Variant, variant_def_id) =
+                    self.typeck_results.borrow().qpath_res(qpath, hir_id)
                 {
                     for param in
                         [param_to_point_at, fallback_param_to_point_at, self_param_to_point_at]
@@ -193,10 +190,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         }
                     }
                 }
-                if let Some(param_to_point_at) = param_to_point_at
-                    && self.point_at_path_if_possible(error, def_id, param_to_point_at, qpath)
+
+                for param in [param_to_point_at, fallback_param_to_point_at, self_param_to_point_at]
+                    .into_iter()
+                    .flatten()
                 {
-                    return true;
+                    if self.point_at_path_if_possible(error, def_id, param, qpath) {
+                        return true;
+                    }
                 }
             }
             _ => {}
@@ -214,10 +215,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ) -> bool {
         match qpath {
             hir::QPath::Resolved(_, path) => {
-                if let Some(segment) = path.segments.last()
-                    && self.point_at_generic_if_possible(error, def_id, param, segment)
-                {
-                    return true;
+                for segment in path.segments.iter().rev() {
+                    if let Res::Def(kind, def_id) = segment.res
+                        && !matches!(kind, DefKind::Mod | DefKind::ForeignMod)
+                        && self.point_at_generic_if_possible(error, def_id, param, segment)
+                    {
+                        return true;
+                    }
                 }
             }
             hir::QPath::TypeRelative(_, segment) => {
@@ -618,14 +622,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             };
 
             let variant_def_id = match expr_struct_def_kind {
-                hir::def::DefKind::Struct => {
+                DefKind::Struct => {
                     if in_ty_adt.did() != expr_struct_def_id {
                         // FIXME: Deal with type aliases?
                         return Err(expr);
                     }
                     expr_struct_def_id
                 }
-                hir::def::DefKind::Variant => {
+                DefKind::Variant => {
                     // If this is a variant, its parent is the type definition.
                     if in_ty_adt.did() != self.tcx.parent(expr_struct_def_id) {
                         // FIXME: Deal with type aliases?
@@ -727,14 +731,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             };
 
             let variant_def_id = match expr_struct_def_kind {
-                hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, hir::def::CtorKind::Fn) => {
+                DefKind::Ctor(hir::def::CtorOf::Struct, hir::def::CtorKind::Fn) => {
                     if in_ty_adt.did() != self.tcx.parent(expr_ctor_def_id) {
                         // FIXME: Deal with type aliases?
                         return Err(expr);
                     }
                     self.tcx.parent(expr_ctor_def_id)
                 }
-                hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, hir::def::CtorKind::Fn) => {
+                DefKind::Ctor(hir::def::CtorOf::Variant, hir::def::CtorKind::Fn) => {
                     // For a typical enum like
                     // `enum Blah<T> { Variant(T) }`
                     // we get the following resolutions:
diff --git a/tests/ui/const-generics/exhaustive-value.stderr b/tests/ui/const-generics/exhaustive-value.stderr
@@ -1,8 +1,8 @@
 error[E0277]: the trait bound `(): Foo<N>` is not satisfied
-  --> $DIR/exhaustive-value.rs:262:5
+  --> $DIR/exhaustive-value.rs:262:16
    |
 LL |     <() as Foo<N>>::test()
-   |     ^^^^^^^^^^^^^^^^^^^^ the trait `Foo<N>` is not implemented for `()`
+   |                ^ the trait `Foo<N>` is not implemented for `()`
    |
    = help: the following other types implement trait `Foo<N>`:
              <() as Foo<0>>
diff --git a/tests/ui/generic-const-items/unsatisfied-bounds.stderr b/tests/ui/generic-const-items/unsatisfied-bounds.stderr
@@ -27,10 +27,10 @@ LL |     Infallible: From<T>;
    |                 ^^^^^^^ required by this bound in `K`
 
 error[E0277]: the trait bound `Vec<u8>: Copy` is not satisfied
-  --> $DIR/unsatisfied-bounds.rs:32:13
+  --> $DIR/unsatisfied-bounds.rs:32:26
    |
 LL |     let _ = <() as Trait<Vec<u8>>>::A;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `Vec<u8>`
+   |                          ^^^^^^^ the trait `Copy` is not implemented for `Vec<u8>`
    |
 note: required by a bound in `Trait::A`
   --> $DIR/unsatisfied-bounds.rs:17:12
diff --git a/tests/ui/trait-bounds/enum-unit-variant-trait-bound.rs b/tests/ui/trait-bounds/enum-unit-variant-trait-bound.rs
@@ -0,0 +1,6 @@
+// Regression test for one part of issue #105306.
+
+fn main() {
+    let _ = Option::<[u8]>::None;
+    //~^ ERROR the size for values of type `[u8]` cannot be known at compilation time
+}
diff --git a/tests/ui/trait-bounds/enum-unit-variant-trait-bound.stderr b/tests/ui/trait-bounds/enum-unit-variant-trait-bound.stderr
@@ -0,0 +1,13 @@
+error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
+  --> $DIR/enum-unit-variant-trait-bound.rs:4:22
+   |
+LL |     let _ = Option::<[u8]>::None;
+   |                      ^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `[u8]`
+note: required by a bound in `None`
+  --> $SRC_DIR/core/src/option.rs:LL:COL
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/suggest-where-clause.stderr b/tests/ui/traits/suggest-where-clause.stderr
@@ -38,32 +38,32 @@ LL + fn check<T: Iterator, U>() {
    |
 
 error[E0277]: the trait bound `u64: From<T>` is not satisfied
-  --> $DIR/suggest-where-clause.rs:15:5
+  --> $DIR/suggest-where-clause.rs:15:18
    |
 LL |     <u64 as From<T>>::from;
-   |     ^^^^^^^^^^^^^^^^^^^^^^ the trait `From<T>` is not implemented for `u64`
+   |                  ^ the trait `From<T>` is not implemented for `u64`
    |
 help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
    |
 LL | fn check<T: Iterator, U: ?Sized>() where u64: From<T> {
    |                                    ++++++++++++++++++
 
 error[E0277]: the trait bound `u64: From<<T as Iterator>::Item>` is not satisfied
-  --> $DIR/suggest-where-clause.rs:18:5
+  --> $DIR/suggest-where-clause.rs:18:18
    |
 LL |     <u64 as From<<T as Iterator>::Item>>::from;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<<T as Iterator>::Item>` is not implemented for `u64`
+   |                  ^^^^^^^^^^^^^^^^^^^^^ the trait `From<<T as Iterator>::Item>` is not implemented for `u64`
    |
 help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
    |
 LL | fn check<T: Iterator, U: ?Sized>() where u64: From<<T as Iterator>::Item> {
    |                                    ++++++++++++++++++++++++++++++++++++++
 
 error[E0277]: the trait bound `Misc<_>: From<T>` is not satisfied
-  --> $DIR/suggest-where-clause.rs:23:5
+  --> $DIR/suggest-where-clause.rs:23:22
    |
 LL |     <Misc<_> as From<T>>::from;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<T>` is not implemented for `Misc<_>`
+   |                      ^ the trait `From<T>` is not implemented for `Misc<_>`
 
 error[E0277]: the size for values of type `[T]` cannot be known at compilation time
   --> $DIR/suggest-where-clause.rs:28:20

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`use crate::FnCtxt;`
`2`	`2`	`use rustc_hir as hir;`
`3`		`-use rustc_hir::def::Res;`
	`3`	`+use rustc_hir::def::{DefKind, Res};`
`4`	`4`	`use rustc_hir::def_id::DefId;`
`5`	`5`	`use rustc_infer::{infer::type_variable::TypeVariableOriginKind, traits::ObligationCauseCode};`
`6`	`6`	`use rustc_middle::ty::{self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor};`
`@@ -133,15 +133,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`	`}`
`136`		`- // Notably, we only point to params that are local to the`
`137`		`- // item we're checking, since those are the ones we are able`
`138`		- // to look in the final `hir::PathSegment` for. Everything else
`139`		- // would require a deeper search into the `qpath` than I think
`140`		`- // is worthwhile.`
`141`		`- if let Some(param_to_point_at) = param_to_point_at`
`142`		`- && self.point_at_path_if_possible(error, def_id, param_to_point_at, qpath)`
	`136`	`+`
	`137`	`+ for param in [param_to_point_at, fallback_param_to_point_at, self_param_to_point_at]`
	`138`	`+ .into_iter()`
	`139`	`+ .flatten()`
`143`	`140`	`{`
`144`		`- return true;`
	`141`	`+ if self.point_at_path_if_possible(error, def_id, param, qpath) {`
	`142`	`+ return true;`
	`143`	`+ }`
`145`	`144`	`}`
`146`	`145`	`}`
`147`	`146`	`hir::ExprKind::MethodCall(segment, receiver, args, ..) => {`
`@@ -168,10 +167,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`168`	`167`	`}`
`169`	`168`	`}`
`170`	`169`	`hir::ExprKind::Struct(qpath, fields, ..) => {`
`171`		`- if let Res::Def(`
`172`		`- hir::def::DefKind::Struct \| hir::def::DefKind::Variant,`
`173`		`- variant_def_id,`
`174`		`- ) = self.typeck_results.borrow().qpath_res(qpath, hir_id)`
	`170`	`+ if let Res::Def(DefKind::Struct \| DefKind::Variant, variant_def_id) =`
	`171`	`+ self.typeck_results.borrow().qpath_res(qpath, hir_id)`
`175`	`172`	`{`
`176`	`173`	`for param in`
`177`	`174`	`[param_to_point_at, fallback_param_to_point_at, self_param_to_point_at]`
`@@ -193,10 +190,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`193`	`190`	`}`
`194`	`191`	`}`
`195`	`192`	`}`
`196`		`- if let Some(param_to_point_at) = param_to_point_at`
`197`		`- && self.point_at_path_if_possible(error, def_id, param_to_point_at, qpath)`
	`193`	`+`
	`194`	`+ for param in [param_to_point_at, fallback_param_to_point_at, self_param_to_point_at]`
	`195`	`+ .into_iter()`
	`196`	`+ .flatten()`
`198`	`197`	`{`
`199`		`- return true;`
	`198`	`+ if self.point_at_path_if_possible(error, def_id, param, qpath) {`
	`199`	`+ return true;`
	`200`	`+ }`
`200`	`201`	`}`
`201`	`202`	`}`
`202`	`203`	`_ => {}`
`@@ -214,10 +215,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`214`	`215`	`) -> bool {`
`215`	`216`	`match qpath {`
`216`	`217`	`hir::QPath::Resolved(_, path) => {`
`217`		`- if let Some(segment) = path.segments.last()`
`218`		`- && self.point_at_generic_if_possible(error, def_id, param, segment)`
`219`		`- {`
`220`		`- return true;`
	`218`	`+ for segment in path.segments.iter().rev() {`
	`219`	`+ if let Res::Def(kind, def_id) = segment.res`
	`220`	`+ && !matches!(kind, DefKind::Mod \| DefKind::ForeignMod)`
	`221`	`+ && self.point_at_generic_if_possible(error, def_id, param, segment)`
	`222`	`+ {`
	`223`	`+ return true;`
	`224`	`+ }`
`221`	`225`	`}`
`222`	`226`	`}`
`223`	`227`	`hir::QPath::TypeRelative(_, segment) => {`
`@@ -618,14 +622,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`618`	`622`	`};`
`619`	`623`
`620`	`624`	`let variant_def_id = match expr_struct_def_kind {`
`621`		`- hir::def::DefKind::Struct => {`
	`625`	`+ DefKind::Struct => {`
`622`	`626`	`if in_ty_adt.did() != expr_struct_def_id {`
`623`	`627`	`// FIXME: Deal with type aliases?`
`624`	`628`	`return Err(expr);`
`625`	`629`	`}`
`626`	`630`	`expr_struct_def_id`
`627`	`631`	`}`
`628`		`- hir::def::DefKind::Variant => {`
	`632`	`+ DefKind::Variant => {`
`629`	`633`	`// If this is a variant, its parent is the type definition.`
`630`	`634`	`if in_ty_adt.did() != self.tcx.parent(expr_struct_def_id) {`
`631`	`635`	`// FIXME: Deal with type aliases?`
`@@ -727,14 +731,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`727`	`731`	`};`
`728`	`732`
`729`	`733`	`let variant_def_id = match expr_struct_def_kind {`
`730`		`- hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, hir::def::CtorKind::Fn) => {`
	`734`	`+ DefKind::Ctor(hir::def::CtorOf::Struct, hir::def::CtorKind::Fn) => {`
`731`	`735`	`if in_ty_adt.did() != self.tcx.parent(expr_ctor_def_id) {`
`732`	`736`	`// FIXME: Deal with type aliases?`
`733`	`737`	`return Err(expr);`
`734`	`738`	`}`
`735`	`739`	`self.tcx.parent(expr_ctor_def_id)`
`736`	`740`	`}`
`737`		`- hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, hir::def::CtorKind::Fn) => {`
	`741`	`+ DefKind::Ctor(hir::def::CtorOf::Variant, hir::def::CtorKind::Fn) => {`
`738`	`742`	`// For a typical enum like`
`739`	`743`	// `enum Blah<T> { Variant(T) }`
`740`	`744`	`// we get the following resolutions:`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`	`1`	error[E0277]: the trait bound `(): Foo<N>` is not satisfied
`2`		`- --> $DIR/exhaustive-value.rs:262:5`
	`2`	`+ --> $DIR/exhaustive-value.rs:262:16`
`3`	`3`	`\|`
`4`	`4`	`LL \| <() as Foo<N>>::test()`
`5`		- \| ^^^^^^^^^^^^^^^^^^^^ the trait `Foo<N>` is not implemented for `()`
	`5`	+ \| ^ the trait `Foo<N>` is not implemented for `()`
`6`	`6`	`\|`
`7`	`7`	= help: the following other types implement trait `Foo<N>`:
`8`	`8`	`<() as Foo<0>>`
Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,10 @@ LL \| Infallible: From<T>;`
`27`	`27`	\| ^^^^^^^ required by this bound in `K`
`28`	`28`
`29`	`29`	error[E0277]: the trait bound `Vec<u8>: Copy` is not satisfied
`30`		`- --> $DIR/unsatisfied-bounds.rs:32:13`
	`30`	`+ --> $DIR/unsatisfied-bounds.rs:32:26`
`31`	`31`	`\|`
`32`	`32`	`LL \| let _ = <() as Trait<Vec<u8>>>::A;`
`33`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `Vec<u8>`
	`33`	+ \| ^^^^^^^ the trait `Copy` is not implemented for `Vec<u8>`
`34`	`34`	`\|`
`35`	`35`	note: required by a bound in `Trait::A`
`36`	`36`	`--> $DIR/unsatisfied-bounds.rs:17:12`
Original file line number	Diff line number	Diff line change
`@@ -38,32 +38,32 @@ LL + fn check<T: Iterator, U>() {`
`38`	`38`	`\|`
`39`	`39`
`40`	`40`	error[E0277]: the trait bound `u64: From<T>` is not satisfied
`41`		`- --> $DIR/suggest-where-clause.rs:15:5`
	`41`	`+ --> $DIR/suggest-where-clause.rs:15:18`
`42`	`42`	`\|`
`43`	`43`	`LL \| <u64 as From<T>>::from;`
`44`		- \| ^^^^^^^^^^^^^^^^^^^^^^ the trait `From<T>` is not implemented for `u64`
	`44`	+ \| ^ the trait `From<T>` is not implemented for `u64`
`45`	`45`	`\|`
`46`	`46`	help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
`47`	`47`	`\|`
`48`	`48`	`LL \| fn check<T: Iterator, U: ?Sized>() where u64: From<T> {`
`49`	`49`	`\| ++++++++++++++++++`
`50`	`50`
`51`	`51`	error[E0277]: the trait bound `u64: From<<T as Iterator>::Item>` is not satisfied
`52`		`- --> $DIR/suggest-where-clause.rs:18:5`
	`52`	`+ --> $DIR/suggest-where-clause.rs:18:18`
`53`	`53`	`\|`
`54`	`54`	`LL \| <u64 as From<<T as Iterator>::Item>>::from;`
`55`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<<T as Iterator>::Item>` is not implemented for `u64`
	`55`	+ \| ^^^^^^^^^^^^^^^^^^^^^ the trait `From<<T as Iterator>::Item>` is not implemented for `u64`
`56`	`56`	`\|`
`57`	`57`	help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
`58`	`58`	`\|`
`59`	`59`	`LL \| fn check<T: Iterator, U: ?Sized>() where u64: From<<T as Iterator>::Item> {`
`60`	`60`	`\| ++++++++++++++++++++++++++++++++++++++`
`61`	`61`
`62`	`62`	error[E0277]: the trait bound `Misc<_>: From<T>` is not satisfied
`63`		`- --> $DIR/suggest-where-clause.rs:23:5`
	`63`	`+ --> $DIR/suggest-where-clause.rs:23:22`
`64`	`64`	`\|`
`65`	`65`	`LL \| <Misc<_> as From<T>>::from;`
`66`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<T>` is not implemented for `Misc<_>`
	`66`	+ \| ^ the trait `From<T>` is not implemented for `Misc<_>`
`67`	`67`
`68`	`68`	error[E0277]: the size for values of type `[T]` cannot be known at compilation time
`69`	`69`	`--> $DIR/suggest-where-clause.rs:28:20`