Implement consecutive shorthand projections

Author: fmease

compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs

@@ -115,7 +115,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     pub(super) fn complain_about_assoc_item_not_found<I>(
         &self,
         all_candidates: impl Fn() -> I,
-        qself: AssocItemQSelf,
+        qself: AssocItemQSelf<'tcx>,
         assoc_kind: ty::AssocKind,
         assoc_name: Ident,
         span: Span,

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -202,18 +202,20 @@ pub trait HirTyLowerer<'tcx> {
 /// The "qualified self" of an associated item path.
 ///
 /// For diagnostic purposes only.
-enum AssocItemQSelf {
+enum AssocItemQSelf<'tcx> {
     Trait(DefId),
     TyParam(LocalDefId, Span),
     SelfTyAlias,
+    AssocTy(Ty<'tcx>),
 }
 
-impl AssocItemQSelf {
-    fn to_string(&self, tcx: TyCtxt<'_>) -> String {
+impl<'tcx> AssocItemQSelf<'tcx> {
+    fn to_string(&self, tcx: TyCtxt<'tcx>) -> String {
         match *self {
             Self::Trait(def_id) => tcx.def_path_str(def_id),
             Self::TyParam(def_id, _) => tcx.hir().ty_param_name(def_id).to_string(),
             Self::SelfTyAlias => kw::SelfUpper.to_string(),
+            Self::AssocTy(ty) => ty.to_string(),
         }
     }
 }
@@ -925,7 +927,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     fn probe_single_bound_for_assoc_item<I>(
         &self,
         all_candidates: impl Fn() -> I,
-        qself: AssocItemQSelf,
+        qself: AssocItemQSelf<'tcx>,
         assoc_kind: ty::AssocKind,
         assoc_name: Ident,
         span: Span,
@@ -1147,15 +1149,45 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 )?
             }
             (
-                &ty::Param(_),
-                Res::SelfTyParam { trait_: param_did } | Res::Def(DefKind::TyParam, param_did),
+                ty::Param(_),
+                Res::SelfTyParam { trait_: param_def_id }
+                | Res::Def(DefKind::TyParam, param_def_id),
             ) => self.probe_single_ty_param_bound_for_assoc_item(
-                param_did.expect_local(),
+                param_def_id.expect_local(),
                 qself.span,
                 ty::AssocKind::Type,
                 assoc_ident,
                 span,
             )?,
+            // FIXME(fmease):
+            // Require the pre-lowered projectee (the HIR QSelf) to have `DefKind::AssocTy`. Rephrased,
+            // `T::Assoc::Assoc` typeck'ing shouldn't imply `Identity<T::Assoc>::Assoc` typeck'ing where
+            // `Identity` is an eager (i.e., non-lazy) type alias. We should do this
+            // * for consistency with lazy type aliases (`ty::Weak`)
+            // * for consistency with the fact that `T::Assoc` typeck'ing doesn't imply `Identity<T>::Assoc`
+            //   typeck'ing
+            (ty::Alias(ty::Projection, alias_ty), _ /* Res::Def(DefKind::AssocTy, _) */) => {
+                // FIXME: Utilizing `item_bounds` for this is cycle-prone.
+                let predicates = tcx.item_bounds(alias_ty.def_id).instantiate(tcx, alias_ty.args);
+
+                self.probe_single_bound_for_assoc_item(
+                    || {
+                        let trait_refs = predicates.iter().filter_map(|pred| {
+                            pred.as_trait_clause().map(|t| t.map_bound(|t| t.trait_ref))
+                        });
+                        traits::transitive_bounds_that_define_assoc_item(
+                            tcx,
+                            trait_refs,
+                            assoc_ident,
+                        )
+                    },
+                    AssocItemQSelf::AssocTy(qself_ty),
+                    ty::AssocKind::Type,
+                    assoc_ident,
+                    span,
+                    None,
+                )?
+            }
             _ => {
                 let reported = if variant_resolution.is_some() {
                     // Variant in type position
@@ -1303,6 +1335,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 );
             });
         }
+
         Ok((ty, DefKind::AssocTy, assoc_ty.def_id))
     }
 

src/tools/tidy/src/issues.txt

@@ -1845,7 +1845,6 @@ ui/issues/issue-23024.rs
 ui/issues/issue-23036.rs
 ui/issues/issue-23041.rs
 ui/issues/issue-23046.rs
-ui/issues/issue-23073.rs
 ui/issues/issue-2311-2.rs
 ui/issues/issue-2311.rs
 ui/issues/issue-2312.rs

tests/ui/associated-types/consecutive-shorthand-projections-ambiguous.rs

@@ -0,0 +1,16 @@
+trait ChooseMe {
+    type Type;
+}
+
+trait PickMe {
+    type Type;
+}
+
+trait HaveItAll {
+    type See: ChooseMe + PickMe;
+}
+
+struct Env<T: HaveItAll>(T::See::Type);
+//~^ ERROR ambiguous associated type `Type` in bounds of `<T as HaveItAll>::See`
+
+fn main() {}

tests/ui/associated-types/consecutive-shorthand-projections-ambiguous.stderr

@@ -0,0 +1,24 @@
+error[E0221]: ambiguous associated type `Type` in bounds of `<T as HaveItAll>::See`
+  --> $DIR/consecutive-shorthand-projections-ambiguous.rs:13:26
+   |
+LL |     type Type;
+   |     --------- ambiguous `Type` from `ChooseMe`
+...
+LL |     type Type;
+   |     --------- ambiguous `Type` from `PickMe`
+...
+LL | struct Env<T: HaveItAll>(T::See::Type);
+   |                          ^^^^^^^^^^^^ ambiguous associated type `Type`
+   |
+help: use fully-qualified syntax to disambiguate
+   |
+LL | struct Env<T: HaveItAll>(<<T as HaveItAll>::See as ChooseMe>::Type);
+   |                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: use fully-qualified syntax to disambiguate
+   |
+LL | struct Env<T: HaveItAll>(<<T as HaveItAll>::See as PickMe>::Type);
+   |                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0221`.

tests/ui/associated-types/consecutive-shorthand-projections-not-in-item-bounds.rs

@@ -0,0 +1,11 @@
+// FIXME: Description
+
+fn parametrized<T: Trait<Ty: Trait>>() {
+    let _: T::Ty::Ty; //~ ERROR associated type `Ty` not found for `<T as Trait>::Ty`
+}
+
+trait Trait {
+    type Ty;
+}
+
+fn main() {}

tests/ui/associated-types/consecutive-shorthand-projections-not-in-item-bounds.stderr

@@ -0,0 +1,9 @@
+error[E0220]: associated type `Ty` not found for `<T as Trait>::Ty`
+  --> $DIR/consecutive-shorthand-projections-not-in-item-bounds.rs:4:19
+   |
+LL |     let _: T::Ty::Ty;
+   |                   ^^ there is an associated type `Ty` in the trait `Trait`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0220`.

tests/ui/associated-types/consecutive-shorthand-projections-struct-construction.rs

@@ -0,0 +1,19 @@
+//@ check-pass
+
+fn make<T: Indir0<Ty: Indir1<Ty = Struct>>>() {
+    let _ = T::Ty::Ty { field: 0 };
+}
+
+trait Indir0 {
+    type Ty: Indir1;
+}
+
+trait Indir1 {
+    type Ty;
+}
+
+struct Struct {
+    field: i32
+}
+
+fn main() {}

tests/ui/associated-types/consecutive-shorthand-projections.rs

@@ -0,0 +1,75 @@
+//@ check-pass
+
+fn factory0<T: Factory>() {
+    let _: T::Output::Category;
+}
+
+fn factory1<T: Factory<Output: Product<Category = u16>>>(category: u16) {
+    let _: T::Output::Category = category;
+}
+
+fn factory2<T: Factory>(_: T::Output::Category) {}
+
+trait Factory {
+    type Output: Product;
+}
+
+impl Factory for () {
+    type Output = u128;
+}
+
+trait Product {
+    type Category;
+}
+
+impl Product for u128 {
+    type Category = u16;
+}
+
+/////////////////////////
+
+fn chain<C: Chain<Link = C>>(chain: C) {
+    let _: C::Link::Link::Link::Link::Link = chain;
+}
+
+trait Chain { type Link: Chain; }
+
+impl Chain for () {
+    type Link = Self;
+}
+
+/////////////////////////
+
+fn scope<'r, T: Main<'static, (i32, U), 1>, U, const Q: usize>() {
+    let _: T::Next<'r, (), Q>::Final;
+}
+
+trait Main<'a, T, const N: usize> {
+    type Next<'b, U, const M: usize>: Aux<'a, 'b, (T, U), N, M>;
+}
+
+impl<'a, T, const N: usize> Main<'a, T, N> for () {
+    type Next<'_b, _U, const _M: usize> = ();
+}
+
+trait Aux<'a, 'b, T, const N: usize, const M: usize> {
+    type Final;
+}
+
+impl<'a, 'b, T, const N: usize, const M: usize> Aux<'a, 'b, T, N, M> for () {
+    type Final = [[(T, &'a (), &'b ()); N]; M];
+}
+
+/////////////////////////
+
+fn main() {
+    factory0::<()>();
+    factory1::<()>(360);
+    factory2::<()>(720);
+    let _: <() as Factory>::Output::Category;
+
+    chain(());
+    let _: <() as Chain>::Link::Link::Link;
+
+    scope::<(), bool, 32>();
+}

tests/ui/issues/issue-23073.rs renamed to tests/ui/associated-types/defaults-23073.rs

@@ -1,9 +1,12 @@
+//@ check-pass
+
 #![feature(associated_type_defaults)]
 
 trait Foo { type T; }
+
 trait Bar {
     type Foo: Foo;
-    type FooT = <<Self as Bar>::Foo>::T; //~ ERROR ambiguous associated type
+    type FooT = <<Self as Bar>::Foo>::T;
 }
 
 fn main() {}

tests/ui/associated-types/non-consecutive-shorthand-projections.lazy.stderr

@@ -0,0 +1,14 @@
+error[E0223]: ambiguous associated type
+  --> $DIR/non-consecutive-shorthand-projections.rs:16:12
+   |
+LL |     let _: Identity<T::Project>::Project;
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: if there were a trait named `Example` with associated type `Project` implemented for `Identity<<T as Trait>::Project>`, you could use the fully-qualified path
+   |
+LL |     let _: <Identity<<T as Trait>::Project> as Example>::Project;
+   |            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0223`.

tests/ui/associated-types/non-consecutive-shorthand-projections.rs

@@ -0,0 +1,19 @@
+// FIXME(fmease): Proper explainer.
+// Of course, under #22519 (arbitrary shorthand projections), this should obviously typeck.
+// For reference, `T::Alias` typeck'ing does *not* imply `Identity<T>::Alias` typeck'ing.
+//@ revisions: eager lazy
+//@[eager] check-pass
+#![cfg_attr(lazy, feature(lazy_type_alias), allow(incomplete_features))]
+
+type Identity<T> = T;
+
+trait Trait {
+    type Project: Trait;
+}
+
+fn scope<T: Trait>() {
+    // FIXME(fmease): Reject this under [eager], too!
+    let _: Identity<T::Project>::Project; //[lazy]~ ERROR ambiguous associated type
+}
+
+fn main() {}

tests/ui/issues/issue-23073.stderr

@@ -1,6 +1,5 @@
 // Check that qualified paths with type parameters
 // fail during type checking and not during parsing
-
 struct S;
 
 trait Tr {
@@ -15,7 +14,6 @@ impl S {
     fn f<T>() {}
 }
 
-type A = <S as Tr>::A::f<u8>;
-//~^ ERROR ambiguous associated type
+type A = <S as Tr>::A::f<u8>; //~ ERROR associated type `f` not found for `<S as Tr>::A`
 
 fn main() {}

tests/ui/qualified/qualified-path-params-2.rs

@@ -1,14 +1,9 @@
-error[E0223]: ambiguous associated type
-  --> $DIR/qualified-path-params-2.rs:18:10
+error[E0220]: associated type `f` not found for `<S as Tr>::A`
+  --> $DIR/qualified-path-params-2.rs:17:24
    |
 LL | type A = <S as Tr>::A::f<u8>;
-   |          ^^^^^^^^^^^^^^^^^^^
-   |
-help: if there were a trait named `Example` with associated type `f` implemented for `<S as Tr>::A`, you could use the fully-qualified path
-   |
-LL | type A = <<S as Tr>::A as Example>::f;
-   |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   |                        ^ there is a similarly named associated type `A` in the trait `Tr`
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0223`.
+For more information about this error, try `rustc --explain E0220`.

tests/ui/qualified/qualified-path-params-2.stderr

@@ -33,7 +33,7 @@ fn main() {
     <u8 as Tr>::N::NN; //~ ERROR cannot find associated type `N` in trait `Tr`
     <u8 as E>::N::NN; //~ ERROR expected trait, found enum `E`
     <u8 as A>::N::NN; //~ ERROR expected trait, found type alias `A`
-    let _: <u8 as Tr>::Y::NN; //~ ERROR ambiguous associated type
+    let _: <u8 as Tr>::Y::NN; //~ ERROR associated type `NN` not found for `<u8 as Tr>::Y`
     let _: <u8 as E>::Y::NN; //~ ERROR expected trait, found enum `E`
     <u8 as Tr>::Y::NN; //~ ERROR no associated item named `NN` found for type `u16`
     <u8 as E>::Y::NN; //~ ERROR expected trait, found enum `E`