Auto merge of #96094 - Elliot-Roberts:fix_doctests, r=compiler-errors

Begin fixing all the broken doctests in `compiler/`

Begins to fix #95994.
All of them pass now but 24 of them I've marked with `ignore HELP (<explanation>)` (asking for help) as I'm unsure how to get them to work / if we should leave them as they are.
There are also a few that I marked `ignore` that could maybe be made to work but seem less important.
Each `ignore` has a rough "reason" for ignoring after it parentheses, with

- `(pseudo-rust)` meaning "mostly rust-like but contains foreign syntax"
- `(illustrative)` a somewhat catchall for either a fragment of rust that doesn't stand on its own (like a lone type), or abbreviated rust with ellipses and undeclared types that would get too cluttered if made compile-worthy.
- `(not-rust)` stuff that isn't rust but benefits from the syntax highlighting, like MIR.
- `(internal)` uses `rustc_*` code which would be difficult to make work with the testing setup.

Those reason notes are a bit inconsistently applied and messy though. If that's important I can go through them again and try a more principled approach. When I run `rg '```ignore \(' .` on the repo, there look to be lots of different conventions other people have used for this sort of thing. I could try unifying them all if that would be helpful.

I'm not sure if there was a better existing way to do this but I wrote my own script to help me run all the doctests and wade through the output. If that would be useful to anyone else, I put it here: https://github.com/Elliot-Roberts/rust_doctest_fixing_tool

compiler/rustc_middle/src/ty/mod.rs

@@ -1030,9 +1030,9 @@ impl<'tcx> Predicate<'tcx> {
 /// their values.
 ///
 /// Example:
-///
-///     struct Foo<T, U: Bar<T>> { ... }
-///
+/// ```ignore (illustrative)
+/// struct Foo<T, U: Bar<T>> { ... }
+/// ```
 /// Here, the `GenericPredicates` for `Foo` would contain a list of bounds like
 /// `[[], [U:Bar<T>]]`. Now if there were some particular reference
 /// like `Foo<isize,usize>`, then the `InstantiatedPredicates` would be `[[],
@@ -1090,9 +1090,9 @@ pub struct OpaqueHiddenType<'tcx> {
     /// The type variable that represents the value of the opaque type
     /// that we require. In other words, after we compile this function,
     /// we will be created a constraint like:
-    ///
-    ///     Foo<'a, T> = ?C
-    ///
+    /// ```ignore (pseudo-rust)
+    /// Foo<'a, T> = ?C
+    /// ```
     /// where `?C` is the value of this type variable. =) It may
     /// naturally refer to the type and lifetime parameters in scope
     /// in this function, though ultimately it should only reference
@@ -1133,7 +1133,7 @@ rustc_index::newtype_index! {
     ///
     /// To make this more concrete, consider this program:
     ///
-    /// ```
+    /// ```ignore (illustrative)
     /// struct Foo { }
     /// fn bar<T>(x: T) {
     ///   let y: for<'a> fn(&'a u8, Foo) = ...;
@@ -1172,7 +1172,7 @@ impl UniverseIndex {
     /// corresponds to entering a `forall` quantifier. So, for
     /// example, suppose we have this type in universe `U`:
     ///
-    /// ```
+    /// ```ignore (illustrative)
     /// for<'a> fn(&'a u32)
     /// ```
     ///
@@ -1959,7 +1959,7 @@ pub enum ImplOverlapKind {
     /// The widely-used version 0.1.0 of the crate `traitobject` had accidentally relied
     /// that difference, making what reduces to the following set of impls:
     ///
-    /// ```
+    /// ```compile_fail,(E0119)
     /// trait Trait {}
     /// impl Trait for dyn Send + Sync {}
     /// impl Trait for dyn Sync + Send {}