In "specify type" suggestion, skip type params that are already known

When we suggest specifying a type for an expression or pattern, like in a `let` binding, we previously would print the entire type as the type system knew it. We now look at the params that have *no* inference variables, so they are fully known to the type system which means that they don't need to be specified.

This helps in suggestions for types that are really long, because we can usually skip most of the type params and make the annotation as short as possible:

```
error[E0282]: type annotations needed for `Result<_, ((..., ..., ..., ...), ..., ..., ...)>`
  --> $DIR/really-long-type-in-let-binding-without-sufficient-type-info.rs:7:9
   |
LL |     let y = Err(x);
   |         ^   ------ type must be known at this point
   |
help: consider giving `y` an explicit type, where the type for type parameter `T` is specified
   |
LL |     let y: Result<T, _> = Err(x);
   |          ++++++++++++++
```

compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs

@@ -18,6 +18,7 @@ use rustc_middle::ty::{
     TypeFoldable, TypeFolder, TypeSuperFoldable, TypeckResults,
 };
 use rustc_span::{BytePos, DUMMY_SP, FileName, Ident, Span, sym};
+use rustc_type_ir::visit::TypeVisitableExt;
 use tracing::{debug, instrument, warn};
 
 use super::nice_region_error::placeholder_error::Highlighted;
@@ -155,26 +156,85 @@ impl UnderspecifiedArgKind {
     }
 }
 
-struct ClosureEraser<'tcx> {
-    tcx: TyCtxt<'tcx>,
+struct ClosureEraser<'a, 'tcx> {
+    infcx: &'a InferCtxt<'tcx>,
+    // When recursing into types, if an ADT has type parameters with a default type we do *not*
+    // want to replace that type parameter with `_`, as it will cause the normally hidden type
+    // parameter to be rendered. The best example of this is `Vec<T, Alloc>`, which we want to
+    // render as `Vec<T>` and not `Vec<T, _>` when `T` is unknown.
+    do_not_hide_nested_type: bool,
 }
 
-impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ClosureEraser<'tcx> {
+impl<'a, 'tcx> ClosureEraser<'a, 'tcx> {
+    fn new_infer(&mut self) -> Ty<'tcx> {
+        self.infcx.next_ty_var(DUMMY_SP)
+    }
+}
+
+impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for ClosureEraser<'a, 'tcx> {
     fn cx(&self) -> TyCtxt<'tcx> {
-        self.tcx
+        self.infcx.tcx
     }
 
     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        match ty.kind() {
+        let prev = self.do_not_hide_nested_type;
+        let ty = match ty.kind() {
             ty::Closure(_, args) => {
+                // For a closure type, we turn it into a function pointer so that it gets rendered
+                // as `fn(args) -> Ret`.
                 let closure_sig = args.as_closure().sig();
                 Ty::new_fn_ptr(
-                    self.tcx,
-                    self.tcx.signature_unclosure(closure_sig, hir::Safety::Safe),
+                    self.cx(),
+                    self.cx().signature_unclosure(closure_sig, hir::Safety::Safe),
                 )
             }
-            _ => ty.super_fold_with(self),
-        }
+            ty::Adt(def, _) => {
+                let generics = self.cx().generics_of(def.did());
+                if generics.own_params.iter().any(|param| param.default_value(self.cx()).is_some())
+                {
+                    // We have a type that has default types, like the allocator in Vec. We decided
+                    // to show `Vec` itself, because it hasn't yet been replaced by an `_` `Infer`,
+                    // but we want to ensure that the type parameter with default types does *not*
+                    // get replaced with `_` because then we'd end up with `Vec<_, _>`, instead of
+                    // `Vec<_>`.
+                    self.do_not_hide_nested_type = true;
+                    ty.super_fold_with(self)
+                } else if ty.has_infer() || self.do_not_hide_nested_type {
+                    // This type has an unsubstituted type variable, meaning that this type has a
+                    // (potentially deeply nested) type parameter from the corresponding type's
+                    // definition. We have explicitly asked this type to not be hidden. In either
+                    // case, we keep the type and don't substitute with `_` just yet.
+                    ty.super_fold_with(self)
+                } else {
+                    // When we have a type that doesn't have any inference variables, so we replace
+                    // the whole thing with `_`. The type system already knows about this type in
+                    // its entirety and it is redundant to specify it for the user. The user only
+                    // needs to specify the type parameters that we *couldn't* figure out.
+                    self.new_infer()
+                }
+            }
+            _ if ty.has_infer() || self.do_not_hide_nested_type => {
+                // This type has a (potentially nested) type parameter that we couldn't figure out.
+                // We will print this depth of type, so at least the type name and at least one of
+                // its type parameters. We unset `do_not_hide_nested_type` because this type can't
+                // have type parameter defaults until next type we hit an ADT.
+                self.do_not_hide_nested_type = false;
+                ty.super_fold_with(self)
+            }
+            // We don't have an unknown type parameter anywhere, replace with `_`.
+            _ => self.new_infer(),
+        };
+        self.do_not_hide_nested_type = prev;
+        ty
+    }
+
+    fn fold_const(&mut self, c: ty::Const<'tcx>) -> ty::Const<'tcx> {
+        let prev = self.do_not_hide_nested_type;
+        // Avoid accidentally erasing the type of the const.
+        self.do_not_hide_nested_type = true;
+        let c = c.super_fold_with(self);
+        self.do_not_hide_nested_type = prev;
+        c
     }
 }
 
@@ -219,9 +279,9 @@ fn ty_to_string<'tcx>(
 ) -> String {
     let mut printer = fmt_printer(infcx, Namespace::TypeNS);
     let ty = infcx.resolve_vars_if_possible(ty);
-    // We use `fn` ptr syntax for closures, but this only works when the closure
-    // does not capture anything.
-    let ty = ty.fold_with(&mut ClosureEraser { tcx: infcx.tcx });
+    // We use `fn` ptr syntax for closures, but this only works when the closure does not capture
+    // anything. We also remove all type parameters that are fully known to the type system.
+    let ty = ty.fold_with(&mut ClosureEraser { infcx, do_not_hide_nested_type: false });
 
     match (ty.kind(), called_method_def_id) {
         // We don't want the regular output for `fn`s because it includes its path in