rustdoc renames parameters with `mut` in async fn

[ebkalderon]

Original:

pub struct Foo;

impl Foo {
    pub async fn good(self, first: usize, second: usize) {}
    pub async fn bad(mut self, mut first: usize, mut second: usize) {}
}

Rendered:

This example was tested on Rust 1.46.0, but it has been broken for quite a while. For example, see Server::serve() in tower-lsp version 0.7.0 (built with Rust 1.43.0-nightly, see docs.rs build info).

[jyn514]

Relevant code:

rust/src/librustdoc/html/format.rs

Line 992 in c9a48d1

if let Some(selfty) = input.to_self() {

Not sure what's going wrong.

[ebkalderon]

Thanks for the helpful hint, @jyn514! However, I'm not convinced this is the root cause because it's happening to all mutable by-value function arguments, not just to async functions with self as the first argument. For example, this free function emits similar results:

pub async fn foo(mut first: usize, mut second: usize) {}

I think the actual root cause may be deeper than the interpretation of Self types, but I can't tell for sure.

[ebkalderon]

This example confirms that the behavior appears to be per-argument instead of per-function. It's not like one bad argument ruins the formatting of the entire function.

pub async fn foo(good: usize, mut bad: usize) {}

Perhaps we could investigate where in the code the __argN text is being generated and work our way backwards to see what is triggering it?

[ebkalderon]

Hmm, the only relevant location I could find through GitHub search is in rustc_ast_lowering in item.rs:

rust/compiler/rustc_ast_lowering/src/item.rs

Line 1104 in 94b4de0

let name = format!("__arg{}", index);

Is rustdoc operating on a desugared form of the AST? I don't think this is the case, since async fn is being successfully displayed here. Is there something else I'm missing?

[jyn514]

Here's the issue:

rust/compiler/rustc_ast_lowering/src/item.rs

Lines 1096 to 1109 in c101116

	// Check if this is a binding pattern, if so, we can optimize and avoid adding a
	// `let <pat> = __argN;` statement. In this case, we do not rename the parameter.
	let (ident, is_simple_parameter) = match parameter.pat.kind {
	hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, _, ident, _) => {
	(ident, true)
	}
	_ => {
	// Replace the ident for bindings that aren't simple.
	let name = format!("__arg{}", index);
	let ident = Ident::from_str(&name);
	(ident, false)
	}
	};

Looks like it should use hir::PatKind::Binding(_, _, ident, _) => { instead. Are you interested in making a PR? ;)

[jyn514]

Is rustdoc operating on a desugared form of the AST? I don't think this is the case, since async fn is being successfully displayed here. Is there something else I'm missing?

Yes, rustdoc works on a desugared version and has to reconstruct the async by hand.

[ebkalderon]

Sure, @jyn514! I will prepare one right away. Thanks for investigating with me. 😄