Reject relaxed bounds inside trait alias bounds

Author: fmease

compiler/rustc_ast_lowering/src/item.rs

@@ -426,7 +426,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     |this| {
                         this.lower_param_bounds(
                             bounds,
-                            RelaxedBoundPolicy::Allowed,
+                            RelaxedBoundPolicy::Forbidden(RelaxedBoundForbiddenReason::TraitAlias),
                             ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                         )
                     },

compiler/rustc_ast_lowering/src/lib.rs

@@ -296,6 +296,7 @@ enum RelaxedBoundPolicy<'a> {
 enum RelaxedBoundForbiddenReason {
     TraitObjectTy,
     SuperTrait,
+    TraitAlias,
     AssocTyBounds,
     LateBoundVarsInScope,
 }
@@ -2132,6 +2133,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         gate("supertrait bounds", "traits");
                         return;
                     }
+                    RelaxedBoundForbiddenReason::TraitAlias => {
+                        gate("trait alias bounds", "trait aliases");
+                        return;
+                    }
                     RelaxedBoundForbiddenReason::AssocTyBounds
                     | RelaxedBoundForbiddenReason::LateBoundVarsInScope => {}
                 };

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -202,9 +202,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             //        where we are guaranteed to catch *all* bounds like in
             //        `Self::lower_poly_trait_ref`. List of concrete issues:
             //        FIXME(more_maybe_bounds): We don't call this for trait object tys, supertrait
-            //                                  bounds or associated type bounds (ATB)!
-            //        FIXME(trait_alias, #143122): We don't call it for the RHS. Arguably however,
-            //                                     AST lowering should reject them outright.
+            //                                  bounds, trait alias bounds, assoc type bounds (ATB)!
             let bounds = collect_relaxed_bounds(hir_bounds, self_ty_where_predicates);
             self.check_and_report_invalid_relaxed_bounds(bounds);
         }

tests/rustdoc-ui/doc-alias-assoc-const.rs

@@ -1,5 +1,3 @@
-#![feature(trait_alias)]
-
 pub struct Foo;
 
 pub trait Bar {

tests/rustdoc-ui/doc-alias-assoc-const.stderr

@@ -1,5 +1,5 @@
 error: `#[doc(alias = "...")]` isn't allowed on associated constant in trait implementation block
-  --> $DIR/doc-alias-assoc-const.rs:10:11
+  --> $DIR/doc-alias-assoc-const.rs:8:11
    |
 LL |     #[doc(alias = "CONST_BAZ")]
    |           ^^^^^^^^^^^^^^^^^^^

tests/ui/sized-hierarchy/trait-aliases.rs

@@ -0,0 +1,20 @@
+// Test that we reject trait object types that effectively (i.e., after trait alias expansion)
+// don't contain any bounds.
+
+#![feature(trait_alias)]
+
+trait Empty0 =;
+
+// Nest a couple of levels deep:
+trait Empty1 = Empty0;
+trait Empty2 = Empty1;
+
+// Straight list expansion:
+type Type0 = dyn Empty2; //~ ERROR at least one trait is required for an object type [E0224]
+
+// Twice:
+trait Empty3 = Empty2 + Empty2;
+
+type Type1 = dyn Empty3; //~ ERROR at least one trait is required for an object type [E0224]
+
+fn main() {}

tests/ui/traits/alias/effectively-empty-trait-object-type.rs

@@ -0,0 +1,21 @@
+error[E0224]: at least one trait is required for an object type
+  --> $DIR/effectively-empty-trait-object-type.rs:13:14
+   |
+LL | trait Empty2 = Empty1;
+   | ------------ this alias does not contain a trait
+...
+LL | type Type0 = dyn Empty2;
+   |              ^^^^^^^^^^
+
+error[E0224]: at least one trait is required for an object type
+  --> $DIR/effectively-empty-trait-object-type.rs:18:14
+   |
+LL | trait Empty3 = Empty2 + Empty2;
+   | ------------ this alias does not contain a trait
+LL |
+LL | type Type1 = dyn Empty3;
+   |              ^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0224`.

tests/ui/traits/alias/effectively-empty-trait-object-type.stderr

@@ -0,0 +1,17 @@
+// Ensure that there are straightforward ways to define "empty" / "trivial" / "unit" trait aliases
+// which don't impose any constraints when used as a bound (since they expand to nothing).
+//@ check-pass
+#![feature(trait_alias)]
+
+trait Empty =;
+
+trait Trivial = where;
+
+trait Unit = where Self:;
+
+fn check<T: ?Sized + Empty>() {}
+
+fn main() {
+    check::<()>(); // OK. "`(): Empty`" is trivially satisfied
+    check::<str>(); // OK. `Empty` is truly empty and isn't implicitly bounded by `Sized`.
+}