Account for type Alias = dyn Trait; in unsized return suggestion

```
error[E0746]: return type cannot have an unboxed trait object
 --> tests/ui/unsized/issue-91801.rs:8:77
  |
8 | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> Validator<'a> {
  |                                                                             ^^^^^^^^^^^^^ doesn't have a size known at compile-time
-Ztrack-diagnostics: created at compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs:566:39
  |
help: box the return type to make a boxed trait object, and wrap all of the returned values in `Box::new`
  |
8 | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> Box<Validator<'a>> {
  |                                                                             ++++             +
help: alternatively, you might be able to borrow from one of the function's arguments
  |
8 | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> &Validator<'a> {
  |                                                                             +
```

Author: estebank

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -1801,13 +1801,43 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         let Some(fn_decl) = self.tcx.hir_node(fn_id).fn_decl() else {
             return false;
         };
-        let hir::FnRetTy::Return(hir::Ty {
-            kind: hir::TyKind::TraitObject(traits @ [tr, ..], _lt, syn),
-            span,
-            ..
-        }) = fn_decl.output
-        else {
-            return false;
+        let (traits, tr, syn, span, can_be_impl) = match fn_decl.output {
+            hir::FnRetTy::Return(hir::Ty {
+                kind: hir::TyKind::TraitObject(traits @ [tr, ..], _lt, syn),
+                span,
+                ..
+            }) => (traits, tr, syn, span, true),
+            hir::FnRetTy::Return(hir::Ty {
+                kind:
+                    hir::TyKind::Path(hir::QPath::Resolved(
+                        None,
+                        hir::Path { res: hir::def::Res::Def(DefKind::TyAlias, def_id), .. },
+                    )),
+                span,
+                ..
+            }) => {
+                if let ty::Dynamic(..) = self.tcx.type_of(def_id).instantiate_identity().kind() {
+                    // We have a `type Alias = dyn Trait;` and a return type `-> Alias`.
+                    if let Some(def_id) = def_id.as_local()
+                        && let node = self.tcx.hir_node_by_def_id(def_id)
+                        && let Some(hir::Ty {
+                            kind: hir::TyKind::TraitObject(traits @ [tr, ..], _lt, syn),
+                            ..
+                        }) = node.ty()
+                    {
+                        (traits, tr, syn, span, false)
+                    } else {
+                        let mut span: MultiSpan = (*span).into();
+                        span.push_span_label(self.tcx.def_span(def_id), "defined here");
+                        err.span_note(span, "the return type is a type alias to a trait object");
+                        err.help("consider boxing or borrowing it");
+                        return false;
+                    }
+                } else {
+                    return false;
+                }
+            }
+            _ => return false,
         };
 
         // Suggest `-> impl Trait`
@@ -1841,14 +1871,17 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         let mut alternatively = "";
         if all_same_ty || visitor.returns.len() == 1 {
             // We're certain that `impl Trait` will work.
-            err.span_suggestion_verbose(
-                // This will work for both `Dyn` and `None` object syntax.
-                span.until(tr.span),
-                "return an `impl Trait` instead of a `dyn Trait`",
-                "impl ",
-                Applicability::MachineApplicable,
-            );
-            alternatively = "alternatively, ";
+            if can_be_impl {
+                // We know it's not a `type Alias = dyn Trait;`.
+                err.span_suggestion_verbose(
+                    // This will work for both `Dyn` and `None` object syntax.
+                    span.until(tr.span),
+                    "return an `impl Trait` instead of a `dyn Trait`",
+                    "impl ",
+                    Applicability::MachineApplicable,
+                );
+                alternatively = "alternatively, ";
+            }
         } else {
             let mut span: MultiSpan =
                 ret_tys.iter().map(|(expr, _)| expr.span).collect::<Vec<Span>>().into();

tests/ui/unsized/issue-91801.stderr

@@ -4,7 +4,14 @@ error[E0746]: return type cannot have an unboxed trait object
 LL | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> Validator<'a> {
    |                                                                             ^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-   = note: the return type of a function must have a statically known size
+help: box the return type to make a boxed trait object, and wrap all of the returned values in `Box::new`
+   |
+LL | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> Box<Validator<'a>> {
+   |                                                                             ++++             +
+help: alternatively, you might be able to borrow from one of the function's arguments
+   |
+LL | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> &Validator<'a> {
+   |                                                                             +
 
 error: aborting due to 1 previous error