99144 enable doctests

compiler/rustc_ast_lowering/Cargo.toml

@@ -3,9 +3,6 @@ name = "rustc_ast_lowering"
 version = "0.0.0"
 edition = "2021"
 
-[lib]
-doctest = false
-
 [dependencies]
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }

compiler/rustc_ast_lowering/src/lib.rs

@@ -1434,21 +1434,20 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     /// Given a function definition like:
     ///
     /// ```rust
+    /// use std::fmt::Debug;
     /// fn test<'a, T: Debug>(x: &'a T) -> impl Debug + 'a {
     ///     x
     /// }
     /// ```
     ///
-    /// we will create a TAIT definition in the HIR like
-    ///
-    /// ```
-    /// type TestReturn<'a, T, 'x> = impl Debug + 'x
-    /// ```
-    ///
-    /// and return a type like `TestReturn<'static, T, 'a>`, so that the function looks like:
+    /// we will create a TAIT definition in the HIR and change the return type so that the function looks like:
     ///
     /// ```rust
-    /// fn test<'a, T: Debug>(x: &'a T) -> TestReturn<'static, T, 'a>
+    /// #![feature(type_alias_impl_trait)]
+    /// use std::fmt::Debug;
+    /// type TestReturn<'x, 'a, T: Debug + 'a> = impl Debug + 'a;
+    /// fn test<'x, 'a, T: Debug>(x: &'a T) -> TestReturn<'x, 'a, T> { x }
+    ///
     /// ```
     ///
     /// Note the subtlety around type parameters! The new TAIT, `TestReturn`, inherits all the

compiler/rustc_builtin_macros/Cargo.toml

@@ -3,9 +3,6 @@ name = "rustc_builtin_macros"
 version = "0.0.0"
 edition = "2021"
 
-[lib]
-doctest = false
-
 [dependencies]
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }

compiler/rustc_builtin_macros/src/deriving/generic/mod.rs

@@ -1036,16 +1036,17 @@ impl<'a> MethodDef<'a> {
     /// ```
     /// But if the struct is `repr(packed)`, we can't use something like
     /// `&self.x` because that might cause an unaligned ref. So for any trait
-    /// method that takes a reference, we use a local block to force a copy.
-    /// This requires that the field impl `Copy`.
-    /// ```
+    /// method that takes a reference, if the struct impls `Copy` then we use a
+    /// local block to force a copy:
+    /// ```rust
     /// # struct A { x: u8, y: u8 }
     /// impl PartialEq for A {
     ///     fn eq(&self, other: &A) -> bool {
     ///         // Desugars to `{ self.x }.eq(&{ other.y }) && ...`
-    ///         { self.x } == { other.y } && { self.y } == { other.y }
+    ///         ({ self.x } == { other.y } && { self.y } == { other.y })
     ///     }
     /// }
+    /// # use std::hash::Hash;
     /// impl Hash for A {
     ///     fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
     ///         ::core::hash::Hash::hash(&{ self.x }, state);

compiler/rustc_expand/Cargo.toml

@@ -4,9 +4,6 @@ version = "0.0.0"
 edition = "2021"
 build = false
 
-[lib]
-doctest = false
-
 [dependencies]
 crossbeam-channel = "0.5.0"
 rustc_ast_passes = { path = "../rustc_ast_passes" }

compiler/rustc_infer/Cargo.toml

@@ -3,9 +3,6 @@ name = "rustc_infer"
 version = "0.0.0"
 edition = "2021"
 
-[lib]
-doctest = false
-
 [dependencies]
 tracing = "0.1"
 rustc_middle = { path = "../rustc_middle" }

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

@@ -31,7 +31,7 @@ pub enum TypeAnnotationNeeded {
     /// ```
     E0282,
     /// An implementation cannot be chosen unambiguously because of lack of information.
-    /// ```compile_fail,E0283
+    /// ```compile_fail
     /// let _ = Default::default();
     /// ```
     E0283,

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/different_lifetimes.rs

@@ -21,7 +21,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
     ///
     /// Consider a case where we have
     ///
-    /// ```compile_fail,E0623
+    /// ```compile_fail
     /// fn foo(x: &mut Vec<&u8>, y: &u8) {
     ///     x.push(y);
     /// }

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/find_anon_type.rs

@@ -14,8 +14,8 @@ use rustc_middle::ty::{self, Region, TyCtxt};
 /// br - the bound region corresponding to the above region which is of type `BrAnon(_)`
 ///
 /// # Example
-/// ```compile_fail,E0623
-/// fn foo(x: &mut Vec<&u8>, y: &u8)
+/// ```
+/// fn foo<'a>(x: &mut Vec<&'a u8>, y: &'a u8)
 ///    { x.push(y); }
 /// ```
 /// The function returns the nested type corresponding to the anonymous region

compiler/rustc_infer/src/infer/outlives/test_type_match.rs

@@ -13,9 +13,11 @@ use crate::infer::region_constraints::VerifyIfEq;
 
 /// Given a "verify-if-eq" type test like:
 ///
+/// ```ignore (not valid syntax)
 ///     exists<'a...> {
 ///         verify_if_eq(some_type, bound_region)
 ///     }
+/// ```
 ///
 /// and the type `test_ty` that the type test is being tested against,
 /// returns:

compiler/rustc_infer/src/infer/outlives/verify.rs

@@ -272,7 +272,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
     ///
     /// It will not, however, work for higher-ranked bounds like:
     ///
-    /// ```compile_fail,E0311
+    /// ```
     /// trait Foo<'a, 'b>
     /// where for<'x> <Self as Foo<'x, 'b>>::Bar: 'x
     /// {

compiler/rustc_infer/src/infer/region_constraints/mod.rs

@@ -238,9 +238,15 @@ pub enum VerifyBound<'tcx> {
 /// like this:
 ///
 /// ```rust
-/// fn foo<'a, 'b, T: SomeTrait<'a>>
+/// # trait SomeTrait<'a> {
+/// #    type Item;
+/// # }
+/// fn foo<'a, 'b, T: SomeTrait<'a>>()
 /// where
 ///    <T as SomeTrait<'a>>::Item: 'b
+/// {
+///
+/// }
 /// ```
 ///
 /// If we have an obligation like `<T as SomeTrait<'?x>>::Item: 'c`, then
@@ -253,7 +259,15 @@ pub enum VerifyBound<'tcx> {
 /// for cases like
 ///
 /// ```rust
-/// where for<'a> <T as SomeTrait<'a>::Item: 'a
+/// # trait SomeTrait<'a> {
+/// #    type Item;
+/// # }
+/// fn foo<'a, 'b, T: SomeTrait<'a>>()
+/// where
+///     <T as SomeTrait<'a>>::Item: 'a
+/// {
+///
+/// }
 /// ```
 ///
 /// The idea is that we have to find some instantiation of `'a` that can