`named_arguments_used_positionally` lint drops some formatting options

[m-ou-se]

fn main() {
    format!("{:x}", a=1);
}

warning: named argument `a` is not used by name
 --> src/main.rs:2:21
  |
2 |     format!("{:x}", a=1);
  |              ----   ^ this named argument is referred to by position in formatting string
  |              |
  |              this formatting argument uses named argument `a` by position
  |
  = note: `#[warn(named_arguments_used_positionally)]` on by default
help: use the named argument by name to avoid ambiguity
  |
2 |     format!("{a}", a=1);
  |               ~

The :x disappears.

[m-ou-se]

I found this while refactoring compiler/rustc_builtin_macros/src/format.rs. Assigning to myself to fix as part of the refactor.

[TaKO8Ki]

I think this problem has already been solved in #100826.

[m-ou-se]

Ah, thanks. Yes, that fixes it.

It seems like it could've been fixed by only removing some 'special' cases in the original code, without span_to_snippet, but I'll do that as part of my refactor.

[TaKO8Ki]

@m-ou-se

It seems like it could've been fixed by only removing some 'special' cases in the original code, without span_to_snippet, but I'll do that as part of my refactor.

Yes. Ideally, we should fix PositionalNamedArg::get_positional_arg_spans as noted in #100826 (comment).

ref: #100891

rust/compiler/rustc_builtin_macros/src/format.rs

Lines 68 to 101 in a8a33cf

	fn get_positional_arg_spans(&self, cx: &Context<'_, '_>) -> (Option<Span>, Option<Span>) {
	if let Some(inner_span) = &self.inner_span_to_replace {
	let span =
	cx.fmtsp.from_inner(InnerSpan { start: inner_span.start, end: inner_span.end });
	(Some(span), Some(span))
	} else if self.ty == PositionalNamedArgType::Arg {
	// In the case of a named argument whose position is implicit, if the argument *has*
	// formatting, there will not be a span to replace. Instead, we insert the name after
	// the `{`, which will be the first character of arg_span. If the argument does *not*
	// have formatting, there may or may not be a span to replace. This is because
	// whitespace is allowed in arguments without formatting (such as `format!("{ }", 1);`)
	// but is not allowed in arguments with formatting (an error will be generated in cases
	// like `format!("{ :1.1}", 1.0f32);`.
	// For the message span, if there is formatting, we want to use the opening `{` and the
	// next character, which will the `:` indicating the start of formatting. If there is
	// not any formatting, we want to underline the entire span.
	cx.arg_spans.get(self.cur_piece).map_or((None, None), |arg_span| {
	if self.has_formatting {
	(
	Some(arg_span.with_lo(arg_span.lo() + BytePos(1)).shrink_to_lo()),
	Some(arg_span.with_hi(arg_span.lo() + BytePos(2))),
	)
	} else {
	let replace_start = arg_span.lo() + BytePos(1);
	let replace_end = arg_span.hi() - BytePos(1);
	let to_replace = arg_span.with_lo(replace_start).with_hi(replace_end);
	(Some(to_replace), Some(*arg_span))
	}
	})
	} else {
	(None, None)
	}
	}
	}

[m-ou-se]

That struct and that method are entirely gone after my refector, and the entire has_formatting will be unnecessary. :)

[TaKO8Ki]

That's great!