Don't crash on ~const trait bounds involving a non-const trait

Author: fmease

compiler/rustc_hir_analysis/src/astconv/generics.rs

@@ -253,18 +253,27 @@ pub fn create_args_for_parent_generic_args<'tcx, 'a>(
                             | GenericParamDefKind::Lifetime,
                             _,
                         ) => {
-                            // SPECIAL CASE FOR DESUGARED EFFECT PARAMS
-                            // This comes from the following example:
+                            // A host effect arg was passed but the generic param isn't the host effect
+                            // param. There are two situations in which we can reach this case.
+                            //
+                            // 1. The number of arguments is incorrect. In this case, an error will
+                            //    already have been emitted, and we can just push an inferred const
+                            //    arg which will just end up resolving to `{const error}`.
+                            // 2. The generic param has a default. Since host effect args are always
+                            //    placed last, it means that we need to infer the arg corresp. to the
+                            //    current param and any following to their default until we reach the
+                            //    host effect param.
+                            //
+                            // For (2), consider the following example:
                             //
                             // ```
                             // #[const_trait]
                             // pub trait PartialEq<Rhs: ?Sized = Self> {}
                             // impl const PartialEq for () {}
                             // ```
                             //
-                            // Since this is a const impl, we need to insert `<false>` at the end of
-                            // `PartialEq`'s generics, but this errors since `Rhs` isn't specified.
-                            // To work around this, we infer all arguments until we reach the host param.
+                            // For the trait ref `<() as PartialEq<host>>`, we need to infer the `Rhs`
+                            // and create the generic args `[/*Self*/ (), /*defaulted*/ (), host]`.
                             args.push(ctx.inferred_kind(Some(&args), param, infer_args));
                             params.next();
                         }
@@ -360,7 +369,7 @@ pub fn create_args_for_parent_generic_args<'tcx, 'a>(
 
                 (Some(&arg), None) => {
                     // We should never be able to reach this point with well-formed input.
-                    // There are three situations in which we can encounter this issue.
+                    // There are four situations in which we can encounter this issue.
                     //
                     //  1. The number of arguments is incorrect. In this case, an error
                     //     will already have been emitted, and we can ignore it.
@@ -369,9 +378,22 @@ pub fn create_args_for_parent_generic_args<'tcx, 'a>(
                     //     user.
                     //  3. We've inferred some lifetimes, which have been provided later (i.e.
                     //     after a type or const). We want to throw an error in this case.
+                    //  4. A host effect argument was passed but the generic params don't
+                    //     contain a host effect param. This can happen if a `~const` trait
+                    //     bound modifier was placed on a non-const trait. Since the lowerer
+                    //     has no way of knowing if the trait is const or not, it synthesizes
+                    //     host effect args unconditionally. We will emit an error later and
+                    //     thus we can ignore it.
 
                     if arg_count.correct.is_ok()
                         && arg_count.explicit_late_bound == ExplicitLateBound::No
+                        && !matches!(
+                            arg,
+                            GenericArg::Const(hir::ConstArg {
+                                is_desugared_from_effects: true,
+                                ..
+                            })
+                        )
                     {
                         let kind = arg.descr();
                         assert_eq!(kind, "lifetime");

tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-on-non-const-trait.rs

@@ -0,0 +1,9 @@
+// Regression test for issue #117244.
+#![feature(const_trait_impl, effects)]
+
+trait NonConst {}
+
+const fn perform<T: ~const NonConst>() {}
+//~^ ERROR ~const can only be applied to `#[const_trait]` traits
+
+fn main() {}

tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-on-non-const-trait.stderr

@@ -0,0 +1,8 @@
+error: ~const can only be applied to `#[const_trait]` traits
+  --> $DIR/tilde-const-on-non-const-trait.rs:6:28
+   |
+LL | const fn perform<T: ~const NonConst>() {}
+   |                            ^^^^^^^^
+
+error: aborting due to 1 previous error
+