[alternative approach] Introduce const-qualified paths

compiler/rustc_ast/src/ast.rs

@@ -1574,6 +1574,16 @@ impl GenBlockKind {
 pub struct QSelf {
     pub ty: P<Ty>,
 
+    /// The constness of the trait (under feature `const_trait_impl`).
+    ///
+    /// * `<Type as Trait>::AssocTy`: `BoundConstness::Never`
+    /// * `<Type as const Trait>::AssocTy`: `BoundConstness::Always`
+    /// * `<Type as ~const Trait>::AssocTy`: `BoundConstness::Maybe`
+    // FIXME(effects): This is the most convenient place to put this information but
+    // it doesn't make much sense from a conceptual viewpoint since it doesn't have
+    // much to do with the self type.
+    pub constness: BoundConstness,
+
     /// The span of `a::b::Trait` in a path like `<Vec<T> as
     /// a::b::Trait>::AssociatedItem`; in the case where `position ==
     /// 0`, this is an empty span.

compiler/rustc_ast/src/mut_visit.rs

@@ -559,7 +559,7 @@ pub fn noop_visit_path<T: MutVisitor>(Path { segments, span, tokens }: &mut Path
 
 pub fn noop_visit_qself<T: MutVisitor>(qself: &mut Option<P<QSelf>>, vis: &mut T) {
     visit_opt(qself, |qself| {
-        let QSelf { ty, path_span, position: _ } = &mut **qself;
+        let QSelf { ty, constness: _, path_span, position: _ } = &mut **qself;
         vis.visit_ty(ty);
         vis.visit_span(path_span);
     })

compiler/rustc_ast_lowering/src/item.rs

@@ -200,36 +200,35 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 hir::ItemKind::Const(ty, generics, body_id)
             }
             ItemKind::Fn(box Fn {
-                sig: FnSig { decl, header, span: fn_sig_span },
+                sig: FnSig { decl: ast_decl, header, span: fn_sig_span },
                 generics,
                 body,
                 ..
             }) => {
                 self.with_new_scopes(ident.span, |this| {
-                    // Note: we don't need to change the return type from `T` to
-                    // `impl Future<Output = T>` here because lower_body
-                    // only cares about the input argument patterns in the function
-                    // declaration (decl), not the return types.
-                    let coroutine_kind = header.coroutine_kind;
-                    let body_id = this.lower_maybe_coroutine_body(
-                        span,
-                        hir_id,
-                        decl,
-                        coroutine_kind,
-                        body.as_deref(),
-                    );
-
+                    // We lower the generics before we lower the body since the body can bind the host
+                    // effect param via qualified paths of the form `<Type as ~const Trait>::AssocType`.
                     let itctx = ImplTraitContext::Universal;
                     let (generics, decl) =
                         this.lower_generics(generics, header.constness, id, &itctx, |this| {
                             this.lower_fn_decl(
-                                decl,
+                                ast_decl,
                                 id,
                                 *fn_sig_span,
                                 FnDeclKind::Fn,
-                                coroutine_kind,
+                                header.coroutine_kind,
                             )
                         });
+                    // Note: We don't need to change the return type from `T` to `impl Future<Output = T>`
+                    // here because `lower_body` only cares about the input argument patterns in the function
+                    // declaration `decl`, not the return types.
+                    let body_id = this.lower_maybe_coroutine_body(
+                        span,
+                        hir_id,
+                        ast_decl,
+                        header.coroutine_kind,
+                        body.as_deref(),
+                    );
                     let sig = hir::FnSig {
                         decl,
                         header: this.lower_fn_header(*header),
@@ -600,9 +599,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             self.host_param_id = generics
                 .params
                 .iter()
-                .find(|param| {
-                    matches!(param.kind, hir::GenericParamKind::Const { is_host_effect: true, .. })
-                })
+                .rev()
+                .find(|param| param.is_host_effect())
                 .map(|param| param.def_id);
         }
 

compiler/rustc_ast_lowering/src/path.rs

@@ -27,6 +27,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // constness of the impl/bound if this is a trait path
         constness: Option<ast::BoundConstness>,
     ) -> hir::QPath<'hir> {
+        // FIXME(effects): The name isn't great.
+        let trait_constness = qself.as_ref().map(|q| q.constness);
         let qself_position = qself.as_ref().map(|q| q.position);
         let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx));
 
@@ -76,8 +78,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         param_mode,
                         parenthesized_generic_args,
                         itctx,
-                        // if this is the last segment, add constness to the trait path
-                        if i == proj_start - 1 { constness } else { None },
+                        // If this is the last segment, add constness to the trait path.
+                        // FIXME(effects): Is it possible that both constnesses are Some?
+                        if i == proj_start - 1 { constness } else { trait_constness },
                     )
                 },
             )),

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1377,6 +1377,9 @@ impl<'a> State<'a> {
         if qself.position > 0 {
             self.space();
             self.word_space("as");
+            if qself.constness != ast::BoundConstness::Never {
+                self.word_space(qself.constness.as_str());
+            }
             let depth = path.segments.len() - qself.position;
             self.print_path(path, false, depth);
         }

compiler/rustc_hir/src/hir.rs

@@ -304,6 +304,10 @@ impl GenericArg<'_> {
             GenericArg::Type(_) | GenericArg::Const(_) | GenericArg::Infer(_) => true,
         }
     }
+
+    pub fn is_desugared_from_effects(&self) -> bool {
+        matches!(self, GenericArg::Const(ConstArg { is_desugared_from_effects: true, .. }))
+    }
 }
 
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
@@ -381,10 +385,8 @@ impl<'hir> GenericArgs<'hir> {
     pub fn num_generic_params(&self) -> usize {
         self.args
             .iter()
-            .filter(|arg| match arg {
-                GenericArg::Lifetime(_)
-                | GenericArg::Const(ConstArg { is_desugared_from_effects: true, .. }) => false,
-                _ => true,
+            .filter(|arg| {
+                !matches!(arg, GenericArg::Lifetime(_)) && !arg.is_desugared_from_effects()
             })
             .count()
     }
@@ -518,6 +520,10 @@ impl<'hir> GenericParam<'hir> {
     pub fn is_elided_lifetime(&self) -> bool {
         matches!(self.kind, GenericParamKind::Lifetime { kind: LifetimeParamKind::Elided })
     }
+
+    pub fn is_host_effect(&self) -> bool {
+        matches!(self.kind, GenericParamKind::Const { is_host_effect: true, .. })
+    }
 }
 
 /// Records where the generic parameter originated from.