mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
87fed9778e
rust/tests/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

665 lines
21 KiB
Plaintext
Raw Normal View History

macros: support diagnostic derive on enums Signed-off-by: David Wood <david.wood@huawei.com>
2022-09-23 06:49:02 -05:00
error: unsupported type attribute for diagnostic derive enum
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:43:1
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[diag(no_crate_example, code = "E0123")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
macros: support diagnostic derive on enums Signed-off-by: David Wood <david.wood@huawei.com>
2022-09-23 06:49:02 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:46:5
macros: support diagnostic derive on enums Signed-off-by: David Wood <david.wood@huawei.com>
2022-09-23 06:49:02 -05:00
|
LL | Foo,
| ^^^
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
macros: support diagnostic derive on enums Signed-off-by: David Wood <david.wood@huawei.com>
2022-09-23 06:49:02 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:48:5
macros: support diagnostic derive on enums Signed-off-by: David Wood <david.wood@huawei.com>
2022-09-23 06:49:02 -05:00
|
LL | Bar,
| ^^^
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
macros: add helper functions for invalid attrs Remove some duplicated code between both diagnostic derives by introducing helper functions for reporting an error in case of a invalid attribute. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:06:13 -05:00
error: `#[nonsense(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:59:1
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[nonsense(no_crate_example, code = "E0123")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
Make derived SessionDiagnostics generic on diagnostic level Deriving SessionDiagnostic on a type no longer forces that diagnostic to be one of warning, error, or fatal. The level is instead decided when the struct is passed to the respective Handler::emit_*() method.
2022-08-19 08:02:10 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:59:1
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | / #[nonsense(no_crate_example, code = "E0123")]
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
LL | |
LL | |
LL | |
LL | | struct InvalidStructAttr {}
| |___________________________^
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:66:1
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | / #[diag("E0123")]
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
LL | |
LL | | struct InvalidLitNestedAttr {}
| |______________________________^
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: diagnostic slug must be the first argument
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:76:16
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | #[diag(nonsense("foo"), code = "E0123", slug = "foo")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:76:1
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
|
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | / #[diag(nonsense("foo"), code = "E0123", slug = "foo")]
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
LL | |
LL | |
LL | | struct InvalidNestedStructAttr1 {}
| |__________________________________^
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: unknown argument
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:82:8
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
LL | #[diag(nonsense = "...", code = "E0123", slug = "foo")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^^^^^
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
= note: only the `code` parameter is valid after the slug
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:82:1
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
|
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | / #[diag(nonsense = "...", code = "E0123", slug = "foo")]
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
LL | |
LL | |
LL | | struct InvalidNestedStructAttr2 {}
| |__________________________________^
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: unknown argument
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:88:8
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
|
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
LL | #[diag(nonsense = 4, code = "E0123", slug = "foo")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^^^^^
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
= note: only the `code` parameter is valid after the slug
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:88:1
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | / #[diag(nonsense = 4, code = "E0123", slug = "foo")]
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
LL | |
LL | |
LL | | struct InvalidNestedStructAttr3 {}
| |__________________________________^
macros: add helper functions for invalid attrs Remove some duplicated code between both diagnostic derives by introducing helper functions for reporting an error in case of a invalid attribute. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:06:13 -05:00
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: unknown argument
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:94:42
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[diag(no_crate_example, code = "E0123", slug = "foo")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
= note: only the `code` parameter is valid after the slug
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
error: `#[suggestion = ...]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:101:5
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
LL | #[suggestion = "bar"]
| ^^^^^^^^^^^^^^^^^^^^^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
macros: reuse `SetOnce` trait in diagnostic derive `SetOnce` trait was introduced in the subdiagnostic derive to simplify the code a little bit, re-use it in the diagnostic derive too. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:28:21 -05:00
error: specified multiple times
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:108:8
macros: reuse `SetOnce` trait in diagnostic derive `SetOnce` trait was introduced in the subdiagnostic derive to simplify the code a little bit, re-use it in the diagnostic derive too. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:28:21 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[diag(no_crate_example, code = "E0456")]
| ^^^^^^^^^^^^^^^^
macros: reuse `SetOnce` trait in diagnostic derive `SetOnce` trait was introduced in the subdiagnostic derive to simplify the code a little bit, re-use it in the diagnostic derive too. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:28:21 -05:00
|
note: previously specified here
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:107:8
macros: reuse `SetOnce` trait in diagnostic derive `SetOnce` trait was introduced in the subdiagnostic derive to simplify the code a little bit, re-use it in the diagnostic derive too. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:28:21 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[diag(no_crate_example, code = "E0123")]
| ^^^^^^^^^^^^^^^^
macros: reuse `SetOnce` trait in diagnostic derive `SetOnce` trait was introduced in the subdiagnostic derive to simplify the code a little bit, re-use it in the diagnostic derive too. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:28:21 -05:00
error: specified multiple times
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:108:26
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[diag(no_crate_example, code = "E0456")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
note: previously specified here
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:107:26
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[diag(no_crate_example, code = "E0123")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
macros: reuse `SetOnce` trait in diagnostic derive `SetOnce` trait was introduced in the subdiagnostic derive to simplify the code a little bit, re-use it in the diagnostic derive too. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:28:21 -05:00
error: specified multiple times
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:114:42
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[diag(no_crate_example, code = "E0456", code = "E0457")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
note: previously specified here
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:114:26
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[diag(no_crate_example, code = "E0456", code = "E0457")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: diagnostic slug must be the first argument
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:119:43
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[diag(no_crate_example, no_crate::example, code = "E0456")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
Make derived SessionDiagnostics generic on diagnostic level Deriving SessionDiagnostic on a type no longer forces that diagnostic to be one of warning, error, or fatal. The level is instead decided when the struct is passed to the respective Handler::emit_*() method.
2022-08-19 08:02:10 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:124:1
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
LL | struct KindNotProvided {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:127:1
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | / #[diag(code = "E0456")]
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
LL | |
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
LL | | struct SlugNotProvided {}
| |_________________________^
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
macros: support `MultiSpan` in diag derives Add support for `MultiSpan` with any of the attributes that work on a `Span` - requires that diagnostic logic generated for these attributes are emitted in the by-move block rather than the by-ref block that they would normally have been generated in. Signed-off-by: David Wood <david.wood@huawei.com>
2022-07-11 11:15:31 -05:00
error: the `#[primary_span]` attribute can only be applied to fields of type `Span` or `MultiSpan`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:138:5
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
macros: rename `#[message]` to `#[primary_span]` Small commit renaming `#[message]` to `#[primary_span]` as this more accurately reflects what it does now. Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:50:45 -05:00
LL | #[primary_span]
| ^^^^^^^^^^^^^^^
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
macros: add helper functions for invalid attrs Remove some duplicated code between both diagnostic derives by introducing helper functions for reporting an error in case of a invalid attribute. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:06:13 -05:00
error: `#[nonsense]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:146:5
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
LL | #[nonsense]
| ^^^^^^^^^^^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
macros: support `MultiSpan` in diag derives Add support for `MultiSpan` with any of the attributes that work on a `Span` - requires that diagnostic logic generated for these attributes are emitted in the by-move block rather than the by-ref block that they would normally have been generated in. Signed-off-by: David Wood <david.wood@huawei.com>
2022-07-11 11:15:31 -05:00
error: the `#[label(...)]` attribute can only be applied to fields of type `Span` or `MultiSpan`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:163:5
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[label(no_crate_label)]
| ^^^^^^^^^^^^^^^^^^^^^^^^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
error: `name` doesn't refer to a field on this type
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:171:46
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[suggestion(no_crate_suggestion, code = "{name}")]
| ^^^^^^^^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
error: invalid format string: expected `'}'` but string was terminated
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:176:10
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
UPDATE - rename DiagnosticHandler macro to Diagnostic
2022-09-18 10:46:56 -05:00
LL | #[derive(Diagnostic)]
Update tests.
2022-08-26 11:52:08 -05:00
| ^^^^^^^^^^ expected `'}'` in format string
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
= note: if you intended to print `{`, you can escape it using `{{`
UPDATE - rename DiagnosticHandler macro to Diagnostic
2022-09-18 10:46:56 -05:00
= note: this error originates in the derive macro `Diagnostic` (in Nightly builds, run with -Z macro-backtrace for more info)
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
error: invalid format string: unmatched `}` found
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:186:10
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
UPDATE - rename DiagnosticHandler macro to Diagnostic
2022-09-18 10:46:56 -05:00
LL | #[derive(Diagnostic)]
Update tests.
2022-08-26 11:52:08 -05:00
| ^^^^^^^^^^ unmatched `}` in format string
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
= note: if you intended to print `}`, you can escape it using `}}`
UPDATE - rename DiagnosticHandler macro to Diagnostic
2022-09-18 10:46:56 -05:00
= note: this error originates in the derive macro `Diagnostic` (in Nightly builds, run with -Z macro-backtrace for more info)
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
macros: support `MultiSpan` in diag derives Add support for `MultiSpan` with any of the attributes that work on a `Span` - requires that diagnostic logic generated for these attributes are emitted in the by-move block rather than the by-ref block that they would normally have been generated in. Signed-off-by: David Wood <david.wood@huawei.com>
2022-07-11 11:15:31 -05:00
error: the `#[label(...)]` attribute can only be applied to fields of type `Span` or `MultiSpan`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:206:5
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[label(no_crate_label)]
| ^^^^^^^^^^^^^^^^^^^^^^^^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
error: suggestion without `code = "..."`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:225:5
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[suggestion(no_crate_suggestion)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: invalid nested attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:233:18
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
macros: support translatable suggestions Extends support for generating `DiagnosticMessage::FluentIdentifier` messages from `SessionDiagnostic` derive to `#[suggestion]`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 07:10:13 -05:00
LL | #[suggestion(nonsense = "bar")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^^^^^
macros: add helper functions for invalid attrs Remove some duplicated code between both diagnostic derives by introducing helper functions for reporting an error in case of a invalid attribute. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:06:13 -05:00
|
Use translatable diagnostics in `rustc_const_eval`
2023-05-17 05:30:14 -05:00
= help: only `no_span`, `style`, `code` and `applicability` are valid nested attributes
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
error: suggestion without `code = "..."`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:233:5
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
LL | #[suggestion(nonsense = "bar")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: invalid nested attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:242:18
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
macros: support translatable suggestions Extends support for generating `DiagnosticMessage::FluentIdentifier` messages from `SessionDiagnostic` derive to `#[suggestion]`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 07:10:13 -05:00
LL | #[suggestion(msg = "bar")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^
macros: add helper functions for invalid attrs Remove some duplicated code between both diagnostic derives by introducing helper functions for reporting an error in case of a invalid attribute. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:06:13 -05:00
|
Use translatable diagnostics in `rustc_const_eval`
2023-05-17 05:30:14 -05:00
= help: only `no_span`, `style`, `code` and `applicability` are valid nested attributes
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
error: suggestion without `code = "..."`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:242:5
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
LL | #[suggestion(msg = "bar")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
error: wrong field type for suggestion
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:265:5
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | / #[suggestion(no_crate_suggestion, code = "This is suggested code")]
Revert "Auto merge of #79132 - pietroalbini:beta-next, r=Mark-Simulacrum" This was landed on master instead of beta!
2020-11-18 04:18:40 -06:00
LL | |
LL | | suggestion: Applicability,
| |_____________________________^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
macros: update session diagnostic errors Small commit adding backticks around types and annotations in the error messages from the session diagnostic derive. Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-30 04:04:03 -05:00
= help: `#[suggestion(...)]` should be applied to fields of type `Span` or `(Span, Applicability)`
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
Ensure #[suggestion] is only applied to correct tuple types
2022-09-10 07:43:07 -05:00
error: specified multiple times
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:281:24
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
Ensure #[suggestion] is only applied to correct tuple types
2022-09-10 07:43:07 -05:00
LL | suggestion: (Span, Span, Applicability),
| ^^^^
|
note: previously specified here
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:281:18
Ensure #[suggestion] is only applied to correct tuple types
2022-09-10 07:43:07 -05:00
|
LL | suggestion: (Span, Span, Applicability),
| ^^^^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
Ensure #[suggestion] is only applied to correct tuple types
2022-09-10 07:43:07 -05:00
error: specified multiple times
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:289:33
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
|
Ensure #[suggestion] is only applied to correct tuple types
2022-09-10 07:43:07 -05:00
LL | suggestion: (Applicability, Applicability, Span),
| ^^^^^^^^^^^^^
|
note: previously specified here
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:289:18
Ensure #[suggestion] is only applied to correct tuple types
2022-09-10 07:43:07 -05:00
|
LL | suggestion: (Applicability, Applicability, Span),
| ^^^^^^^^^^^^^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
error: `#[label = ...]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:296:5
macros: add helper functions for invalid attrs Remove some duplicated code between both diagnostic derives by introducing helper functions for reporting an error in case of a invalid attribute. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 22:06:13 -05:00
|
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
LL | #[label = "bar"]
| ^^^^^^^^^^^^^^^^
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
Point to previous applicability when declared multiple times
2022-09-10 07:48:01 -05:00
error: specified multiple times
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:447:5
macros: allow setting applicability in attribute In the initial implementation of the `SessionSubdiagnostic`, the `Applicability` of a suggestion can be set both as a field and as part of the attribute, this commit adds the same support to the original `SessionDiagnostic` derive. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 23:43:36 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[suggestion(no_crate_suggestion, code = "...", applicability = "maybe-incorrect")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Point to previous applicability when declared multiple times
2022-09-10 07:48:01 -05:00
|
note: previously specified here
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:449:24
Point to previous applicability when declared multiple times
2022-09-10 07:48:01 -05:00
|
LL | suggestion: (Span, Applicability),
| ^^^^^^^^^^^^^
macros: allow setting applicability in attribute In the initial implementation of the `SessionSubdiagnostic`, the `Applicability` of a suggestion can be set both as a field and as part of the attribute, this commit adds the same support to the original `SessionDiagnostic` derive. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 23:43:36 -05:00
error: invalid applicability
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:455:69
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[suggestion(no_crate_suggestion, code = "...", applicability = "batman")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^^^^^
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
Migrate most of `rustc_builtin_macros` to diagnostic impls Co-authored-by: Joe ST <joe@fbstj.net> Co-authored-by: Michael Goulet <michael@errs.io>
2023-04-08 14:37:41 -05:00
error: the `#[help(...)]` attribute can only be applied to fields of type `Span`, `MultiSpan`, `bool` or `()`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:522:5
Allow using `bool` for optional diagnostics
2023-02-27 06:54:11 -06:00
|
LL | #[help(no_crate_help)]
| ^^^^^^^^^^^^^^^^^^^^^^
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: a diagnostic slug must be the first argument to the attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:531:32
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[label(no_crate_label, foo)]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
Use translatable diagnostics in `rustc_const_eval`
2023-05-17 05:30:14 -05:00
error: only `no_span` is a valid nested attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:539:29
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[label(no_crate_label, foo = "...")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
Use translatable diagnostics in `rustc_const_eval`
2023-05-17 05:30:14 -05:00
error: only `no_span` is a valid nested attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:547:29
macros: allow setting applicability in attribute In the initial implementation of the `SessionSubdiagnostic`, the `Applicability` of a suggestion can be set both as a field and as part of the attribute, this commit adds the same support to the original `SessionDiagnostic` derive. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 23:43:36 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[label(no_crate_label, foo("..."))]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^
macros: allow setting applicability in attribute In the initial implementation of the `SessionSubdiagnostic`, the `Applicability` of a suggestion can be set both as a field and as part of the attribute, this commit adds the same support to the original `SessionDiagnostic` derive. Signed-off-by: David Wood <david.wood@huawei.com>
2022-04-26 23:43:36 -05:00
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
error: `#[primary_span]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:559:5
macros: add diagnostic derive for lints `SessionDiagnostic` isn't suitable for use on lints as whether or not it creates an error or a warning is decided at compile-time by the macro, whereas lints decide this at runtime based on the location of the lint being reported (as it will depend on the user's `allow`/`deny` attributes, etc). Re-using most of the machinery for `SessionDiagnostic`, this macro introduces a `LintDiagnostic` derive which implements a `DecorateLint` trait, taking a `LintDiagnosticBuilder` and adding to the lint according to the diagnostic struct.
2022-06-30 02:57:45 -05:00
|
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | #[primary_span]
| ^^^^^^^^^^^^^^^
macros: add diagnostic derive for lints `SessionDiagnostic` isn't suitable for use on lints as whether or not it creates an error or a warning is decided at compile-time by the macro, whereas lints decide this at runtime based on the location of the lint being reported (as it will depend on the user's `allow`/`deny` attributes, etc). Re-using most of the machinery for `SessionDiagnostic`, this macro introduces a `LintDiagnostic` derive which implements a `DecorateLint` trait, taking a `LintDiagnosticBuilder` and adding to the lint according to the diagnostic struct.
2022-06-30 02:57:45 -05:00
|
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
= help: the `primary_span` field attribute is not valid for lint diagnostics
macros: add diagnostic derive for lints `SessionDiagnostic` isn't suitable for use on lints as whether or not it creates an error or a warning is decided at compile-time by the macro, whereas lints decide this at runtime based on the location of the lint being reported (as it will depend on the user's `allow`/`deny` attributes, etc). Re-using most of the machinery for `SessionDiagnostic`, this macro introduces a `LintDiagnostic` derive which implements a `DecorateLint` trait, taking a `LintDiagnosticBuilder` and adding to the lint according to the diagnostic struct.
2022-06-30 02:57:45 -05:00
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
error: `#[error(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:579:1
macros: add diagnostic derive for lints `SessionDiagnostic` isn't suitable for use on lints as whether or not it creates an error or a warning is decided at compile-time by the macro, whereas lints decide this at runtime based on the location of the lint being reported (as it will depend on the user's `allow`/`deny` attributes, etc). Re-using most of the machinery for `SessionDiagnostic`, this macro introduces a `LintDiagnostic` derive which implements a `DecorateLint` trait, taking a `LintDiagnosticBuilder` and adding to the lint according to the diagnostic struct.
2022-06-30 02:57:45 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[error(no_crate_example, code = "E0123")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
macros: add diagnostic derive for lints `SessionDiagnostic` isn't suitable for use on lints as whether or not it creates an error or a warning is decided at compile-time by the macro, whereas lints decide this at runtime based on the location of the lint being reported (as it will depend on the user's `allow`/`deny` attributes, etc). Re-using most of the machinery for `SessionDiagnostic`, this macro introduces a `LintDiagnostic` derive which implements a `DecorateLint` trait, taking a `LintDiagnosticBuilder` and adding to the lint according to the diagnostic struct.
2022-06-30 02:57:45 -05:00
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:579:1
Disallow #[primary_span] on LintDiagnostics
2022-08-19 08:04:34 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | / #[error(no_crate_example, code = "E0123")]
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | |
LL | |
LL | |
LL | | struct ErrorAttribute {}
| |________________________^
Disallow #[primary_span] on LintDiagnostics
2022-08-19 08:04:34 -05:00
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
translations: rename warn_ to warning The macro warn_ was named like that because it the keyword warn is a built-in attribute and at the time this macro was created the word 'warning' was also taken. However it is no longer the case and we can rename warn_ to warning.
2022-08-24 10:57:10 -05:00
error: `#[warn_(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:586:1
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[warn_(no_crate_example, code = "E0123")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:586:1
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | / #[warn_(no_crate_example, code = "E0123")]
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | |
LL | |
LL | |
translations: rename warn_ to warning The macro warn_ was named like that because it the keyword warn is a built-in attribute and at the time this macro was created the word 'warning' was also taken. However it is no longer the case and we can rename warn_ to warning.
2022-08-24 10:57:10 -05:00
LL | | struct WarnAttribute {}
| |_______________________^
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
error: `#[lint(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:593:1
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[lint(no_crate_example, code = "E0123")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:593:1
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | / #[lint(no_crate_example, code = "E0123")]
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | |
LL | |
LL | |
LL | | struct LintAttributeOnSessionDiag {}
| |____________________________________^
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the `#[diag(...)]` attribute, such as `#[diag(hir_analysis_example_error)]`
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
error: `#[lint(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:600:1
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[lint(no_crate_example, code = "E0123")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
`ui-fulldeps`: adopt to the new rustc lint API
2022-09-22 09:25:05 -05:00
error: `#[lint(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:600:1
`ui-fulldeps`: adopt to the new rustc lint API
2022-09-22 09:25:05 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[lint(no_crate_example, code = "E0123")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Add a note to duplicate diagnostics
2023-10-04 13:34:50 -05:00
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
`ui-fulldeps`: adopt to the new rustc lint API
2022-09-22 09:25:05 -05:00
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
error: diagnostic slug not specified
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:600:1
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | / #[lint(no_crate_example, code = "E0123")]
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | |
LL | |
LL | |
`ui-fulldeps`: adopt to the new rustc lint API
2022-09-22 09:25:05 -05:00
LL | |
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | | struct LintAttributeOnLintDiag {}
| |_________________________________^
|
Update translation tests
2022-10-22 04:08:09 -05:00
= help: specify the slug as the first argument to the attribute, such as `#[diag(compiletest_example)]`
Disallow #[primary_span] on LintDiagnostics
2022-08-19 08:04:34 -05:00
Ensure code= in #[suggestion(...)] is only set once
2022-09-10 07:28:12 -05:00
error: specified multiple times
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:610:53
Ensure code= in #[suggestion(...)] is only set once
2022-09-10 07:28:12 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[suggestion(no_crate_suggestion, code = "...", code = ",,,")]
fix errors
2023-04-03 10:11:30 -05:00
| ^^^^
Ensure code= in #[suggestion(...)] is only set once
2022-09-10 07:28:12 -05:00
|
note: previously specified here
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:610:39
Ensure code= in #[suggestion(...)] is only set once
2022-09-10 07:28:12 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[suggestion(no_crate_suggestion, code = "...", code = ",,,")]
fix errors
2023-04-03 10:11:30 -05:00
| ^^^^
Ensure code= in #[suggestion(...)] is only set once
2022-09-10 07:28:12 -05:00
Ensure #[suggestion] is only applied to correct tuple types
2022-09-10 07:43:07 -05:00
error: wrong types for suggestion
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:619:24
Ensure #[suggestion] is only applied to correct tuple types
2022-09-10 07:43:07 -05:00
|
LL | suggestion: (Span, usize),
| ^^^^^
|
= help: `#[suggestion(...)]` on a tuple field must be applied to fields of type `(Span, Applicability)`
error: wrong types for suggestion
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:627:17
Ensure #[suggestion] is only applied to correct tuple types
2022-09-10 07:43:07 -05:00
|
LL | suggestion: (Span,),
| ^^^^^^^
|
= help: `#[suggestion(...)]` on a tuple field must be applied to fields of type `(Span, Applicability)`
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
error: suggestion without `code = "..."`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:634:5
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[suggestion(no_crate_suggestion)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
error: `#[multipart_suggestion(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:641:1
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[multipart_suggestion(no_crate_suggestion)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
= help: consider creating a `Subdiagnostic` instead
Bump syn now that it doesn't affect diagnostics anymore
2023-07-25 07:56:34 -05:00
error: `#[multipart_suggestion(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:644:1
Bump syn now that it doesn't affect diagnostics anymore
2023-07-25 07:56:34 -05:00
|
LL | #[multipart_suggestion()]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: consider creating a `Subdiagnostic` instead
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
error: `#[multipart_suggestion(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:648:5
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[multipart_suggestion(no_crate_suggestion)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
= help: consider creating a `Subdiagnostic` instead
error: `#[suggestion(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:656:1
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[suggestion(no_crate_suggestion, code = "...")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
= help: `#[label]` and `#[suggestion]` can only be applied to fields
error: `#[label]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:665:1
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
LL | #[label]
| ^^^^^^^^
|
= help: `#[label]` and `#[suggestion]` can only be applied to fields
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: `eager` is the only supported nested attribute for `subdiagnostic`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:699:7
macros: `#[subdiagnostic(eager)]` Add support for `eager` argument to the `subdiagnostic` attribute which generates a call to `eager_subdiagnostic`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-03 08:24:17 -05:00
|
LL | #[subdiagnostic(bad)]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^^^^^^^^^^^^^^^
macros: `#[subdiagnostic(eager)]` Add support for `eager` argument to the `subdiagnostic` attribute which generates a call to `eager_subdiagnostic`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-03 08:24:17 -05:00
error: `#[subdiagnostic = ...]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:707:5
macros: `#[subdiagnostic(eager)]` Add support for `eager` argument to the `subdiagnostic` attribute which generates a call to `eager_subdiagnostic`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-03 08:24:17 -05:00
|
LL | #[subdiagnostic = "bad"]
| ^^^^^^^^^^^^^^^^^^^^^^^^
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: `eager` is the only supported nested attribute for `subdiagnostic`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:715:7
macros: `#[subdiagnostic(eager)]` Add support for `eager` argument to the `subdiagnostic` attribute which generates a call to `eager_subdiagnostic`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-03 08:24:17 -05:00
|
LL | #[subdiagnostic(bad, bad)]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^^^^^^^^^^^^^^^^^^^^
macros: `#[subdiagnostic(eager)]` Add support for `eager` argument to the `subdiagnostic` attribute which generates a call to `eager_subdiagnostic`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-03 08:24:17 -05:00
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: `eager` is the only supported nested attribute for `subdiagnostic`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:723:7
macros: `#[subdiagnostic(eager)]` Add support for `eager` argument to the `subdiagnostic` attribute which generates a call to `eager_subdiagnostic`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-03 08:24:17 -05:00
|
LL | #[subdiagnostic("bad")]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^^^^^^^^^^^^^^^^^^^^
macros: `#[subdiagnostic(eager)]` Add support for `eager` argument to the `subdiagnostic` attribute which generates a call to `eager_subdiagnostic`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-03 08:24:17 -05:00
error: `#[subdiagnostic(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:731:5
macros: `#[subdiagnostic(eager)]` Add support for `eager` argument to the `subdiagnostic` attribute which generates a call to `eager_subdiagnostic`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-03 08:24:17 -05:00
|
LL | #[subdiagnostic(eager)]
| ^^^^^^^^^^^^^^^^^^^^^^^
|
Support eager subdiagnostics again
2023-01-08 17:00:41 -06:00
= help: eager subdiagnostics are not supported on lints
macros: `#[subdiagnostic(eager)]` Add support for `eager` argument to the `subdiagnostic` attribute which generates a call to `eager_subdiagnostic`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-03 08:24:17 -05:00
Allow specifying multiple alternative suggestions This allows porting uses of span_suggestions() to diagnostic structs. Doesn't work for multipart_suggestions() because the rank would be reversed - the struct would specify multiple spans, each of which has multiple possible replacements, while multipart_suggestions() creates multiple possible replacements, each with multiple spans.
2022-10-17 12:41:49 -05:00
error: expected at least one string literal for `code(...)`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:789:23
Allow specifying multiple alternative suggestions This allows porting uses of span_suggestions() to diagnostic structs. Doesn't work for multipart_suggestions() because the rank would be reversed - the struct would specify multiple spans, each of which has multiple possible replacements, while multipart_suggestions() creates multiple possible replacements, each with multiple spans.
2022-10-17 12:41:49 -05:00
|
LL | #[suggestion(code())]
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
| ^
Allow specifying multiple alternative suggestions This allows porting uses of span_suggestions() to diagnostic structs. Doesn't work for multipart_suggestions() because the rank would be reversed - the struct would specify multiple spans, each of which has multiple possible replacements, while multipart_suggestions() creates multiple possible replacements, each with multiple spans.
2022-10-17 12:41:49 -05:00
error: `code(...)` must contain only string literals
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:797:23
Allow specifying multiple alternative suggestions This allows porting uses of span_suggestions() to diagnostic structs. Doesn't work for multipart_suggestions() because the rank would be reversed - the struct would specify multiple spans, each of which has multiple possible replacements, while multipart_suggestions() creates multiple possible replacements, each with multiple spans.
2022-10-17 12:41:49 -05:00
|
LL | #[suggestion(code(foo))]
| ^^^
Forbid #[suggestion_*(...)] on Vecs It is ambiguous whether this should produce several `.span_suggestions()` calls or one `.multipart_suggestions()` call.
2022-10-16 09:15:39 -05:00
error: `#[suggestion(...)]` is not a valid attribute
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:821:5
Forbid #[suggestion_*(...)] on Vecs It is ambiguous whether this should produce several `.span_suggestions()` calls or one `.multipart_suggestions()` call.
2022-10-16 09:15:39 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[suggestion(no_crate_suggestion, code = "")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Forbid #[suggestion_*(...)] on Vecs It is ambiguous whether this should produce several `.span_suggestions()` calls or one `.multipart_suggestions()` call.
2022-10-16 09:15:39 -05:00
|
= note: `#[suggestion(...)]` applied to `Vec` field is ambiguous
= help: to show a suggestion consisting of multiple parts, use a `Subdiagnostic` annotated with `#[multipart_suggestion(...)]`
= help: to show a variable set of suggestions, use a `Vec` of `Subdiagnostic`s annotated with `#[suggestion(...)]`
Bump syn now that it doesn't affect diagnostics anymore
2023-07-25 07:56:34 -05:00
error[E0433]: failed to resolve: maybe a missing crate `core`?
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:54:8
Bump syn now that it doesn't affect diagnostics anymore
2023-07-25 07:56:34 -05:00
|
LL | #[diag = "E0123"]
| ^ maybe a missing crate `core`?
error[E0433]: failed to resolve: maybe a missing crate `core`?
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:797:23
Bump syn now that it doesn't affect diagnostics anymore
2023-07-25 07:56:34 -05:00
|
LL | #[suggestion(code(foo))]
| ^^^ maybe a missing crate `core`?
error[E0433]: failed to resolve: maybe a missing crate `core`?
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:806:25
Bump syn now that it doesn't affect diagnostics anymore
2023-07-25 07:56:34 -05:00
|
LL | #[suggestion(code = 3)]
| ^ maybe a missing crate `core`?
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
error: cannot find attribute `nonsense` in this scope
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:59:3
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[nonsense(no_crate_example, code = "E0123")]
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
| ^^^^^^^^
error: cannot find attribute `nonsense` in this scope
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:146:7
macros: translatable struct attrs and warnings Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 02:35:17 -05:00
|
LL | #[nonsense]
| ^^^^^^^^
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
error: cannot find attribute `error` in this scope
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:579:3
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[error(no_crate_example, code = "E0123")]
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
| ^^^^^
translations: rename warn_ to warning The macro warn_ was named like that because it the keyword warn is a built-in attribute and at the time this macro was created the word 'warning' was also taken. However it is no longer the case and we can rename warn_ to warning.
2022-08-24 10:57:10 -05:00
error: cannot find attribute `warn_` in this scope
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:586:3
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[warn_(no_crate_example, code = "E0123")]
translations: rename warn_ to warning The macro warn_ was named like that because it the keyword warn is a built-in attribute and at the time this macro was created the word 'warning' was also taken. However it is no longer the case and we can rename warn_ to warning.
2022-08-24 10:57:10 -05:00
| ^^^^^ help: a built-in attribute with a similar name exists: `warn`
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
error: cannot find attribute `lint` in this scope
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:593:3
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[lint(no_crate_example, code = "E0123")]
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
| ^^^^ help: a built-in attribute with a similar name exists: `link`
error: cannot find attribute `lint` in this scope
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:600:3
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[lint(no_crate_example, code = "E0123")]
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
| ^^^^ help: a built-in attribute with a similar name exists: `link`
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
error: cannot find attribute `multipart_suggestion` in this scope
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:641:3
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[multipart_suggestion(no_crate_suggestion)]
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
| ^^^^^^^^^^^^^^^^^^^^
error: cannot find attribute `multipart_suggestion` in this scope
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:644:3
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
LL | #[multipart_suggestion()]
| ^^^^^^^^^^^^^^^^^^^^
error: cannot find attribute `multipart_suggestion` in this scope
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:648:7
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
|
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
LL | #[multipart_suggestion(no_crate_suggestion)]
Unify subdiagnostic attribute parsing
2022-09-14 10:19:40 -05:00
| ^^^^^^^^^^^^^^^^^^^^
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
error[E0425]: cannot find value `nonsense` in module `crate::fluent_generated`
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:71:8
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
|
Replace #[lint/warning/error] with #[diag]
2022-08-19 08:40:48 -05:00
LL | #[diag(nonsense, code = "E0123")]
errors: generate typed identifiers in each crate Instead of loading the Fluent resources for every crate in `rustc_error_messages`, each crate generates typed identifiers for its own diagnostics and creates a static which are pulled together in the `rustc_driver` crate and provided to the diagnostic emitter. Signed-off-by: David Wood <david.wood@huawei.com>
2022-10-13 04:13:02 -05:00
| ^^^^^^^^ not found in `crate::fluent_generated`
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error[E0425]: cannot find value `__code_34` in this scope
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:803:10
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
|
LL | #[derive(Diagnostic)]
| ^^^^^^^^^^ not found in this scope
|
= note: this error originates in the derive macro `Diagnostic` (in Nightly builds, run with -Z macro-backtrace for more info)
errors: `set_arg` takes `IntoDiagnosticArg` Manual implementors of translatable diagnostics will need to call `set_arg`, not just the derive, so make this function a bit more ergonomic by taking `IntoDiagnosticArg` rather than `DiagnosticArgValue`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-05-07 01:26:03 -05:00
error[E0277]: the trait bound `Hello: IntoDiagnosticArg` is not satisfied
Use `rustc_fluent_macro::fluent_messages!` directly. Currently we always do this: ``` use rustc_fluent_macro::fluent_messages; ... fluent_messages! { "./example.ftl" } ``` But there is no need, we can just do this everywhere: ``` rustc_fluent_macro::fluent_messages! { "./example.ftl" } ``` which is shorter.
2023-11-21 16:53:07 -06:00
--> $DIR/diagnostic-derive.rs:345:12
macros: add `#[no_arg]` to skip `set_arg` call A call to `set_arg` is generated for every field of a `SessionDiagnostic` struct without attributes, but not all types support being an argument, so `#[no_arg]` is introduced to skip these fields. Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 03:02:31 -05:00
|
UPDATE - rename DiagnosticHandler macro to Diagnostic
2022-09-18 10:46:56 -05:00
LL | #[derive(Diagnostic)]
Make spans a bit better
2023-05-03 18:53:44 -05:00
| ---------- required by a bound introduced by this call
...
LL | other: Hello,
| ^^^^^ the trait `IntoDiagnosticArg` is not implemented for `Hello`
errors: `set_arg` takes `IntoDiagnosticArg` Manual implementors of translatable diagnostics will need to call `set_arg`, not just the derive, so make this function a bit more ergonomic by taking `IntoDiagnosticArg` rather than `DiagnosticArgValue`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-05-07 01:26:03 -05:00
|
tests: avoid inadvertent diffs in diag derive test In the diagnostic derive test, a "the following other types implement trait" diagnostic is output which lists rustc types that implement `IntoDiagnosticArg`. As the output of this test can change due to new internal compiler types like implementing `IntoDiagnosticArg`, it can start failing without indicating a problem to be fixed - so normalize that output away. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-29 03:21:44 -05:00
= help: normalized in stderr
errors: `set_arg` takes `IntoDiagnosticArg` Manual implementors of translatable diagnostics will need to call `set_arg`, not just the derive, so make this function a bit more ergonomic by taking `IntoDiagnosticArg` rather than `DiagnosticArgValue`. Signed-off-by: David Wood <david.wood@huawei.com>
2022-05-07 01:26:03 -05:00
note: required by a bound in `DiagnosticBuilder::<'a, G>::set_arg`
Adjust stderr file
2022-08-31 09:46:51 -05:00
--> $COMPILER_DIR/rustc_errors/src/diagnostic_builder.rs:LL:CC
Make spans a bit better
2023-05-03 18:53:44 -05:00
= note: this error originates in the macro `forward` (in Nightly builds, run with -Z macro-backtrace for more info)
macros: add `#[no_arg]` to skip `set_arg` call A call to `set_arg` is generated for every field of a `SessionDiagnostic` struct without attributes, but not all types support being an argument, so `#[no_arg]` is introduced to skip these fields. Signed-off-by: David Wood <david.wood@huawei.com>
2022-03-31 03:02:31 -05:00
fix and bless ui tests 1/2
2023-04-03 09:36:50 -05:00
error: aborting due to 84 previous errors
Add SessionDiagnostic derive macro. Co-authored-by: Oliver Scherer <github35764891676564198441@oli-obk.de>
2020-08-27 05:00:21 -05:00
Bump syn now that it doesn't affect diagnostics anymore
2023-07-25 07:56:34 -05:00
Some errors have detailed explanations: E0277, E0425, E0433.
macros: use typed identifiers in diag derive Using typed identifiers instead of strings with the Fluent identifier enables the diagnostic derive to benefit from the compile-time validation that comes with typed identifiers - use of a non-existent Fluent identifier will not compile. Signed-off-by: David Wood <david.wood@huawei.com>
2022-06-23 08:51:44 -05:00
For more information about an error, try `rustc --explain E0277`.
Reference in New Issue Copy Permalink