"left behind trailing whitespace" in long patterns

[RReverser]

Code like this:

fn put_telescope_synctocoordinates(
    PutTelescopeSynctocoordinatesPathParams {
                    
                        device_number,
                    
                }: PutTelescopeSynctocoordinatesPathParams,
) {
}

triggers "left behind trailing whitespace".

I suppose it's because rustfmt tries to put entire param - both pattern and type - on the same line, fails in doing so as that exceeds the max width, and gives up. Instead, it should probably fallback to something like

fn put_telescope_synctocoordinates(
    PutTelescopeSynctocoordinatesPathParams {
      device_number,
    }: PutTelescopeSynctocoordinatesPathParams,
) {
}

[ytmimi]

Thanks for the report!.

I believe your assessment is correct and we're trying to put the pattern and the type on the same line. After looking into it I think what's happening is there's enough space to write the pattern on a single line so we format it on one line, but there isn't enough space to put both the pattern and the type on one line so rewriting fails, which leads to returning the span unchanged. I did some digging to try and pin that down:

starting at rewrite_fn_base, we eventually call rewrite_params

rustfmt/src/items.rs

Lines 2287 to 2296 in ef91154

	let param_str = rewrite_params(
	context,
	&fd.inputs,
	one_line_budget,
	multi_line_budget,
	indent,
	param_indent,
	params_span,
	fd.c_variadic(),
	)?;

rewrite_params then calls the Rewrite impl for ast::Param, and if it fails to format the param we just return the original span unchanged, which explains the left behind trailing whitespace issue.

rustfmt/src/items.rs

Lines 2595 to 2597 in ef91154

	param
	.rewrite(context, Shape::legacy(multi_line_budget, param_indent))
	.or_else(|| Some(context.snippet(param.span()).to_owned()))

For anyone interested in taking this on I'd start looking at the is_named_param if-else block in the ast::Param Rewrite impl.

rustfmt/src/items.rs

Lines 2035 to 2088 in ef91154

	} else if is_named_param(self) {
	let param_name = &self
	.pat
	.rewrite(context, Shape::legacy(shape.width, shape.indent))?;
	let mut result = combine_strs_with_missing_comments(
	context,
	&param_attrs_result,
	param_name,
	span,
	shape,
	!has_multiple_attr_lines && !has_doc_comments,
	)?;
	if !is_empty_infer(&*self.ty, self.pat.span) {
	let (before_comment, after_comment) =
	get_missing_param_comments(context, self.pat.span, self.ty.span, shape);
	result.push_str(&before_comment);
	result.push_str(colon_spaces(context.config));
	result.push_str(&after_comment);
	let overhead = last_line_width(&result);
	let max_width = shape.width.checked_sub(overhead)?;
	if let Some(ty_str) = self
	.ty
	.rewrite(context, Shape::legacy(max_width, shape.indent))
	{
	result.push_str(&ty_str);
	} else {
	let prev_str = if param_attrs_result.is_empty() {
	param_attrs_result
	} else {
	param_attrs_result + &shape.to_string_with_newline(context.config)
	};
	result = combine_strs_with_missing_comments(
	context,
	&prev_str,
	param_name,
	span,
	shape,
	!has_multiple_attr_lines,
	)?;
	result.push_str(&before_comment);
	result.push_str(colon_spaces(context.config));
	result.push_str(&after_comment);
	let overhead = last_line_width(&result);
	let max_width = shape.width.checked_sub(overhead)?;
	let ty_str = self
	.ty
	.rewrite(context, Shape::legacy(max_width, shape.indent))?;
	result.push_str(&ty_str);
	}
	}
	Some(result)

I'd assume we'll also need to make some changes to rewrite_struct_pat, which gets called as a result of rewriting a struct pattern (the self.pat.rewrite call above Line 2036).

rustfmt/src/patterns.rs

Lines 258 to 260 in ef91154

	PatKind::Struct(ref qself, ref path, ref fields, ellipsis) => {
	rewrite_struct_pat(qself, path, fields, ellipsis, self.span, context, shape)
	}

[sammysheep]

Not sure if this is the right issue to add this to, but "if-let" chains are also "long patterns" and seem to create this issue that breaks formatting (yes, I know the actual formatting of said elements is undecided, but the rest of the formatting died as a result). For example:

            if let Some(ref r) = reverse_regex 
                && let Some(c) = r.captures(s) 
                && let Some(m) = c.get(0) 
            {

Errors out as:

error[internal]: left behind trailing whitespace
   --> /path/to/file.rs:335:335:47
    |
335 |             if let Some(ref r) = reverse_regex 
    |                                               ^
    |

error[internal]: left behind trailing whitespace
   --> /path/to/file.rs:336:336:65
    |
336 |                 && let Some(c) = r.captures(s) 
    |                                                                 ^
    |

error[internal]: left behind trailing whitespace
   --> /path/to/file.rs:337:337:42
    |
337 |                 && let Some(m) = c.get(0) 
    |                                          ^

Formatting works after the trailing spaces are deleted. Using: rustfmt 1.5.1-nightly (a6b7274 2022-10-10)

[calebcartwright]

@sammysheep - thanks for sharing but that's unrelated to this issue so I'm going to minimize that comment as well as this one to keep the issue focused.

It's not that formatting is "broken" in your case; rustfmt is simply leaving exactly what you wrote in the first place, and if you happened to have trailing spaces in your original code then rustfmt is noting that to you for awareness. This happens in many cases, including the one that's the topic of this issue, but also in cases where there are no defined formatting rules, as in let chains which is off topic here.

[YpeKingma]

I have a ¨left behing trailing whitespace" in a let statement, rustc 1.65.0, on arch armv7l, a raspberry pi.
The offending code has a whitespace just after the final ) on the first code line, with the else part added here to the error message:

error[internal]: left behind trailing whitespace
--> /home/ype/p1encrypt-rs/src/p1input.rs:159:159:58

    let Some(first_open_bracket_pos) = line.find('(') 
    else {
        return Err("missing open bracket".to_string());
    };

A commit with the offending the code is on gitlab:
https://gitlab.com/enmprivaggr/enmprv/-/commit/437c1bf1e158f7fc5e3aa03cd91ffa566e0d8de2

Without the backspace, the code formats just fine:
https://gitlab.com/enmprivaggr/enmprv/-/commit/407661172e63bffd13c0c95ff5a9105440e106c9

Does that fit here, or does this look like a new issue?

[YpeKingma]

Looking at the previous comment of @calebcartwright this is off topic here.
I'd expect end of line whitespace to be a target for change by fmt, so I think this is a case of a missing format rule.
Would that qualify as a new issue?

[ytmimi]

@YpeKingma thanks for reaching out, but this is unrelated. to the original issue.

so I think this is a case of a missing format rule.

Correct! The problem you're experiencing stems from the fact that rustfmt doesn't currently handle let-else statements and won't try to format them. rustfmt leaves trailing trailing whitespace as it was in the original input.

Would that qualify as a new issue?
No, this isn't new. You can follow #4914 to keep track of when this is resolved.