format! should be able to parse arbitrary inline expressions and provide a targeted error

[estebank]

format! currently doesn't support inline expressions, like format!("{binding.field}");, but the error it emits while serviceable isn't great:

error: invalid format string: expected `'}'`, found `'.'`
  --> src/main.rs:10:23
   |
10 |     println!("{binding.field}");
   |               -       ^ expected `}` in format string
   |               |
   |               because of this opening brace
   |
   = note: if you intended to print `{`, you can escape it using `{{`

It would be much better experience if we started parsing first field access expressions, potentially method calls and later arbitrary expressions and explicitly told the user "you can't do that, move the expression to its own binding". If we were to ever attempt to support this, prototyping the machinery for diagnostics first would also be informative about its limits or potential problems.

error: invalid format string: field access isn't supported
  --> src/main.rs:10:23
   |
10 |     println!("{binding.field}");
   |                ^^^^^^^^^^^^^ not supported
help: consider using a positional formatting argument instead
   |
10 |     println!("{}", binding.field);
   |               --   +++++++++++++

[Mark-Simulacrum]

Do we really need to parse the inside of the format string? It seems like a potentially reasonable first step here is to add a help: message indicating that only identifiers are supported, not arbitrary expressions, and suggest the position formatting argument.

We could probably have a simple heuristic of longer than 3 characters or similar to avoid most malformed {} contents that aren't actually Rust expressions.

[estebank]

If we want to provide a structured suggestion, we do need to parse the argument. The heuristic is a good stop gap that might be "enough". Being able to parse fn calls, method and field chains and binops could be done "cheaply" and cover the vast majority of likely user mistakes.

[Milo123459]

Could a suggestion be implemented where it is replaced with a format argument and replaced with the argument number? I think that could be a good idea.

[Frankkkkk]

@estebank unless I'm mistaken, this is fixed in rust 1.83:

error: invalid format string: field access isn't supported
  --> examples/test.rs:10:15
   |
10 |     format!("{foo.bar}");
   |               ^^^^^^^ not supported in format string
   |
help: consider using a positional formatting argument instead
   |
10 |     format!("{0}", foo.bar);
   |               ~  +++++++++

[estebank]

@Frankkkkk field access is absolutely the most pressing need from this ticket, but the idea was to allow for partial parsing of arbitrary expressions (like function calls, method calls, and math operations). That being said, I'm ok with us never getting there if the impl cost is too high.