Skip to content

rustdoc wanted features & bugfixes #350

Open
@ojeda

Description

@ojeda

Note: there is the "A-rust-for-linux" label in the rust repository: https://github.com/rust-lang/rust/labels/A-rust-for-linux.

Features that we would like to see

Required (we almost certainly want them)

  • External references map file.

    • The idea is to be able to write intra-doc-like links that point to external resources, e.g.:

      /// Uses the kernel's C [`struct mutex`].
      

      where the URL is automatically provided, e.g. to some C documentation. Similarly, it could be use to avoid duplicating URLs that need to be manually updated, e.g. like a BibTeX database file. For instance, references to external articles, page/webs, papers, Wikipedia entries, etc.

      To define those links, rustdoc could be given a "external references" file containing a map of (term, URL) pairs (e.g. in a JSON or Markdown-references-like file with one reference per line), possibly passed via the CLI, e.g.:

      --external-references-file books.json

      That way, the user is the one that defines the links and terms, possibly exporting them from other tooling (such as a documentation tool for another programming language).

      Multiple files could also be allowed -- having different files for different topics/categories of references may be useful/cleaner for users.

      An interesting extension could be to allow references to contain extra metadata (i.e. not just the URL), like in BibTeX. rustdoc could then potentially render that metadata somehow, like Wikipedia's references (e.g. when clicking them, or when clicking a small information button close to the link, or as a footnote, or on hover...). Another possibility is that, even without any extra metadata, rustdoc could also decide to render them differently than "normal links".

      There is potential for ambiguity with existing links. Possibly a syntax could be provided to disambiguate (whether required in all cases or just in cases of ambiguity), as suggested by @aDotInTheVoid, e.g.:

      /// Uses the kernel's [extern@`struct mutex`].
      

      Currently (Rust 1.78), when one uses an intra-doc link that matches a Markdown one (i.e. the intra-doc link title is the same as the Markdown link label of a link reference definition), rustdoc renders it as the Markdown link, rather than the intra-doc link, without warning, e.g.:

      /// This ambiguous link ([`ThisModule`]) goes to the website, not to the Rust item.
      ///
      /// [`ThisModule`]: https://rust-for-linux.com
      

      An alternative could have been to use:

      --markdown-after-content references.md

      with a references.md file with:

      [Wikipedia]: https://www.wikipedia.org

      but currently (Rust 1.78) those references cannot be used from elsewhere. Instead, a potential --markdown-after-every-item could work.

      Similarly, including the references via include_str! as suggested by @jyn514 works, e.g.:

      /// Here are all the docs, with [Wikipedia] links.
      ///
      #[doc = include_str!("references.md")]

      but requires doing so in each case/item (rather than globally).

    • Status: Idea seemed reasonable to maintainers, RFC to be written.

    • Cc: @aDotInTheVoid, @GuillaumeGomez, @jyn514.

  • rustdoc lint to flag potential intra-doc links.

  • Documentation under conditional compilation.

  • Custom logo/favicon flag (for local/bundled image files).

Nice to have (not critical, we could workaround if needed, etc.)

Low priority (we will likely not use them in the end)

  • Being able to use intra-doc links in "normal" comments.

    • In documentation, we write things like:

      /// See [`SomeType`].
      fn f() {
          // ...
      }

      The idea is to be able to write the same in normal comments:

      // See [`SomeType`].

      This includes things like // SAFETY comments, which tend to refer to types and functions/methods, e.g.:

      // SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership.
      let boxed = unsafe { KBox::from_raw(ptr) };
      // SAFETY: It is safe to send `Arc<T>` to another thread when the underlying `T` is `Sync` ...
      unsafe impl<T: ?Sized + Sync + Send> Send for Arc<T> {}

      The potential advantages would be that:

      • rustdoc could give an error if the link does not exist, just like it does for the documentation, so preventing typos and missing changes in refactors etc. (we had a case of that recently).

      • rustdoc (and IDE tooling) could provide clickable links for those in the source view.

      • It would be more consistent with normal docs, which simplifies e.g. copy-pasting from one to the other.

  • Strip blank lines on both the top and the bottom sides.

Done (stabilized, fixed, not needed anymore, etc.)


Bugs that we would like to see fixed

Required (we almost certainly want them)

Nice to have (probably not critical, we could workaround if needed, etc.)

Low priority (we will likely not use them in the end)

Done (stabilized, fixed, or not needed anymore, etc.)

Metadata

Metadata

Assignees

No one assigned

    Labels

    metaMeta issue.• toolchainRelated to `rustc`, `bindgen`, `rustdoc`, LLVM, Clippy...

    Type

    No type

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions