| Age | Commit message (Collapse) | Author | Lines |
|---|
|
Stabilize `#[cfg(panic = "...")]`
[Stabilization PR](https://rustc-dev-guide.rust-lang.org/stabilization_guide.html#stabilization-pr) for #77443
|
|
It should only include the identifier, or misspelling suggestions will be wrong.
|
|
Rebase commit
|
|
Don't allow {} to refer to implicit captures in format_args.
Fixes #93378
|
|
Accommodate yield points in the format_args expansion
Fixes #93274.
For the case `println!("{} {:?}", "", async {}.await)` in the issue, the expansion before:
```rust
::std::io::_print(
::core::fmt::Arguments::new_v1(
&["", " ", "\n"],
&[
::core::fmt::ArgumentV1::new(&"", ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(&async {}.await, ::core::fmt::Debug::fmt),
],
),
);
```
After:
```rust
::std::io::_print(
::core::fmt::Arguments::new_v1(
&["", " ", "\n"],
&match (&"", &async {}.await) {
_args => [
::core::fmt::ArgumentV1::new(_args.0, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(_args.1, ::core::fmt::Debug::fmt),
],
},
),
);
```
|
|
|
|
Currently fails with:
error: future cannot be sent between threads safely
--> $DIR/src/test/ui/fmt/format-with-yield-point.rs:21:17
|
LL | assert_send(with_await());
| ^^^^^^^^^^^^ future returned by `with_await` is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::Opaque`
note: future is not `Send` as this value is used across an await
--> $DIR/src/test/ui/fmt/format-with-yield-point.rs:11:37
|
LL | println!("{} {:?}", "", async {}.await);
| --------------------------------^^^^^^-
| | |
| | await occurs here, with `$crate::format_args_nl!($($arg)*)` maybe used later
| has type `ArgumentV1<'_>` which is not `Send`
| `$crate::format_args_nl!($($arg)*)` is later dropped here
note: required by a bound in `assert_send`
--> $DIR/src/test/ui/fmt/format-with-yield-point.rs:18:24
|
LL | fn assert_send(_: impl Send) {}
| ^^^^ required by this bound in `assert_send`
error: future cannot be sent between threads safely
--> $DIR/src/test/ui/fmt/format-with-yield-point.rs:22:17
|
LL | assert_send(with_macro_call());
| ^^^^^^^^^^^^^^^^^ future returned by `with_macro_call` is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::Opaque`
note: future is not `Send` as this value is used across an await
--> $DIR/src/test/ui/fmt/format-with-yield-point.rs:6:17
|
LL | async {}.await
| ^^^^^^ await occurs here, with `$crate::format_args_nl!($($arg)*)` maybe used later
...
LL | println!("{} {:?}", "", m!());
| -----------------------------
| | |
| | in this macro invocation
| has type `ArgumentV1<'_>` which is not `Send`
| `$crate::format_args_nl!($($arg)*)` is later dropped here
note: required by a bound in `assert_send`
--> $DIR/src/test/ui/fmt/format-with-yield-point.rs:18:24
|
LL | fn assert_send(_: impl Send) {}
| ^^^^ required by this bound in `assert_send`
= note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 2 previous errors
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Works as expected, and there are widespread reports of success with it,
as well as interest in it.
|
|
|
|
|
|
|
|
Warn when an escaped newline skips multiple lines
Resolves #87319
|
|
* On suggestions that include deletions, use a diff inspired output format
* When suggesting addition, use `+` as underline
* Color highlight modified span
|
|
From what I can tell, the goal of the tests is to ensure that the error
formatting is correct. I think this is still being tested as intended
after this change.
|
|
* Always point at macros, including derive macros
* Point at non-local items that introduce a trait requirement
* On private associated item, point at definition
|
|
|
|
|
|
When there are multiple macros in use, it can be difficult to tell
which one was responsible for producing an error.
|
|
|
|
This extends the `panic_fmt` lint to warn for all cases where the first
argument cannot be interpreted as a format string, as will happen in
Rust 2021.
It suggests to add `"{}", ` to format the message as a string. In the
case of `std::panic!()`, it also suggests the recently stabilized
`std::panic::panic_any()` function as an alternative.
It renames the lint to `non_fmt_panic` to match the lint naming
guidelines.
|
|
|
|
|
|
|
|
|
|
of whole format string
|
|
diagnostics: shorten paths of unique symbols
This is a step towards implementing a fix for #50310, and continuation of the discussion in [Pre-RFC: Nicer Types In Diagnostics - compiler - Rust Internals](https://internals.rust-lang.org/t/pre-rfc-nicer-types-in-diagnostics/11139). Impressed upon me from previous discussion in #21934 that an RFC for this is not needed, and I should just come up with code.
The recent improvements to `use` suggestions that I've contributed have given rise to this implementation. Contrary to previous suggestions, it's rather simple logic, and I believe it only reduces the amount of cognitive load that a developer would need when reading type errors.
-----
If a symbol name can only be imported from one place, and as long as it was not glob-imported anywhere in the current crate, we can trim its printed path to the last component.
This has wide implications on error messages with types, for example, shortening `std::vec::Vec` to just `Vec`, as long as there is no other `Vec` importable from anywhere.
|
|
If a symbol name can only be imported from one place for a type, and
as long as it was not glob-imported anywhere in the current crate, we
can trim its printed path and print only the name.
This has wide implications on error messages with types, for example,
shortening `std::vec::Vec` to just `Vec`, as long as there is no other
`Vec` importable anywhere.
This adds a new '-Z trim-diagnostic-paths=false' option to control this
feature.
On the good path, with no diagnosis printed, we should try to avoid
issuing this query, so we need to prevent trimmed_def_paths query on
several cases.
This change also relies on a previous commit that differentiates
between `Debug` and `Display` on various rustc types, where the latter
is trimmed and presented to the user and the former is not.
|
|
If a comma in a format call is replaced with a similar token, then we
emit an error and continue parsing, instead of stopping at this point.
|
|
Previous implementation used the `Parser::parse_expr` function in order
to extract the format expression. If the first comma following the
format expression was mistakenly replaced with a dot, then the next
format expression was eaten by the function, because it looked as a
syntactically valid expression, which resulted in incorrectly spanned
error messages.
The way the format expression is exctracted is changed: we first look at
the first available token in the first argument supplied to the
`format!` macro call. If it is a string literal, then it is promoted as
a format expression immediatly, otherwise we fall back to the original
`parse_expr`-related method.
This allows us to ensure that the parser won't consume too much tokens
when a typo is made.
A test has been created so that it is ensured that the issue is properly
fixed.
|
|
|
|
Apply suggestion from varkor
Co-authored-by: varkor <github@varkor.com>
|
|
|
|
|
|
|
|
|
|
This prevents accidental dereferences and so forth of the Void type, as well as
cleaning up the error message to reference Opaque rather than the more
complicated PhantomData type.
|
|
Previously:
error: invalid format string: invalid argument name `_x`
--> src/main.rs:2:16
|
2 | println!("{_x}", a=0);
| ^^ invalid argument name in format string
|
= note: argument names cannot start with an underscore
Not supporting identifiers starting with underscore appears to have been
an arbitrary limitation from 2013 in code that was most likely never
reviewed:
https://github.com/rust-lang/rust/pull/8245/files#diff-0347868ef389c805e97636623e4a4ea6R277
The error message was dutifully improved in #50610 but is there any
reason that leading underscore would be a special case?
This commit updates the format_args parser to accept identifiers with
leading underscores.
|
|
Add secondary span labels with no text to make it clear when there's a
mismatch bewteen the positional arguments in a format string and the
arguments to the macro. This shouldn't affect experienced users, but it
should make it easier for newcomers to more clearly understand how
`format!()` and `println!()` are supposed to be used.
```
error: 2 positional arguments in format string, but there is 1 argument
--> file8.rs:2:14
|
2 | format!("{} {}", 1);
| ^^ ^^ -
```
instead of
```
error: 2 positional arguments in format string, but there is 1 argument
--> file8.rs:2:14
|
2 | format!("{} {}", 1);
| ^^ ^^
```
|
|
|
|
|
|
|
|
|
|
|
|
Currently, we deal with escape sequences twice: once when we lex a
string, and a second time when we unescape literals. This PR aims to
remove this duplication, by introducing a new `unescape` mode as a
single source of truth for character escaping rules
|
