    //! This is a module to test doc injection.
    //! ```
    //! fn test() {}
    //! ```

    //! Syntactic name ref highlighting testing
    //! ```rust
    //! extern crate self;
    //! extern crate other as otter;
    //! extern crate core;
    //! trait T { type Assoc; }
    //! fn f<Arg>() -> use<Arg> where (): T<Assoc = ()> {}
    //! ```
    mod outline_module;

    /// ```
    /// let _ = "early doctests should not go boom";
    /// ```
    struct Foo {
        bar: bool,
    }

    /// This is an impl of [`Foo`] with a code block.
    ///
    /// ```
    /// fn foo() {
    ///
    /// }
    /// ```
    impl Foo {
        /// ```
        /// let _ = "Call me
        //    KILLER WHALE
        ///     Ishmael.";
        /// ```
        pub const bar: bool = true;

        /// Constructs a new `Foo`.
        ///
        /// # Examples
        ///
        /// ```
        /// # #![allow(unused_mut)]
        /// let mut foo: Foo = Foo::new();
        /// ```
        pub const fn new() -> Foo {
            Foo { bar: true }
        }

        /// `bar` method on `Foo`.
        ///
        /// # Examples
        ///
        /// ```
        /// use x::y;
        ///
        /// let foo = Foo::new();
        ///
        /// // calls bar on foo
        /// assert!(foo.bar());
        ///
        /// let bar = foo.bar || Foo::bar;
        ///
        /// /* multi-line
        ///        comment */
        ///
        /// let multi_line_string = "Foo
        ///   bar\n
        ///          ";
        ///
        /// ```
        ///
        /// ```rust,no_run
        /// let foobar = Foo::new().bar();
        /// ```
        ///
        /// ~~~rust,no_run
        /// // code block with tilde.
        /// let foobar = Foo::new().bar();
        /// ~~~
        ///
        /// ```
        /// // functions
        /// fn foo<T, const X: usize>(arg: i32) {
        ///     let x: T = X;
        /// }
        /// ```
        ///
        /// ```sh
        /// echo 1
        /// ```
        pub fn foo(&self) -> bool {
            true
        }
    }

    /// [`Foo`](Foo) is a struct
    /// This function is > [`all_the_links`](all_the_links) <
    /// [`noop`](noop) is a macro below
    /// [`Item`] is a struct in the module [`module`]
    ///
    /// [`Item`]: module::Item
    /// [mix_and_match]: ThisShouldntResolve
    pub fn all_the_links() {}

    pub mod module {
        pub struct Item;
    }

    /// ```
    /// macro_rules! noop { ($expr:expr) => { $expr }}
    /// noop!(1);
    /// ```
    macro_rules! noop {
        ($expr:expr) => {
            $expr
        }
    }

    /// ```rust
    /// let _ = example(&[1, 2, 3]);
    /// ```
    ///
    /// ```
    /// loop {}
    #[cfg_attr(not(feature = "false"), doc = "loop {}")]
    #[doc = "loop {}"]
    /// ```
    ///
    #[cfg_attr(feature = "alloc", doc = "```rust")]
    #[cfg_attr(not(feature = "alloc"), doc = "```ignore")]
    /// let _ = example(&alloc::vec![1, 2, 3]);
    /// ```
    pub fn mix_and_match() {}

    /**
    It is beyond me why you'd use these when you got ///
    ```rust
    let _ = example(&[1, 2, 3]);
    ```
    [`block_comments2`] tests these with indentation
     */
    pub fn block_comments() {}

    /**
        Really, I don't get it
        ```rust
        let _ = example(&[1, 2, 3]);
        ```
        [`block_comments`] tests these without indentation
    */
    pub fn block_comments2() {}