diff --git a/Cargo.lock b/Cargo.lock
index 85d3fc1aa7bf7..711892bcfdd87 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4581,7 +4581,6 @@ dependencies = [
  "rustc_errors",
  "rustc_expand",
  "rustc_feature",
- "rustc_fluent_macro",
  "rustc_hir",
  "rustc_index",
  "rustc_macros",
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 3b9ca5ff7288c..8c53d558133ba 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -132,7 +132,6 @@ pub static DEFAULT_LOCALE_RESOURCES: &[&str] = &[
     rustc_parse::DEFAULT_LOCALE_RESOURCE,
     rustc_passes::DEFAULT_LOCALE_RESOURCE,
     rustc_pattern_analysis::DEFAULT_LOCALE_RESOURCE,
-    rustc_resolve::DEFAULT_LOCALE_RESOURCE,
     rustc_trait_selection::DEFAULT_LOCALE_RESOURCE,
     // tidy-alphabetical-end
 ];
diff --git a/compiler/rustc_resolve/Cargo.toml b/compiler/rustc_resolve/Cargo.toml
index dd15e879c6440..01e268d911d24 100644
--- a/compiler/rustc_resolve/Cargo.toml
+++ b/compiler/rustc_resolve/Cargo.toml
@@ -16,7 +16,6 @@ rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_expand = { path = "../rustc_expand" }
 rustc_feature = { path = "../rustc_feature" }
-rustc_fluent_macro = { path = "../rustc_fluent_macro" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_index = { path = "../rustc_index" }
 rustc_macros = { path = "../rustc_macros" }
diff --git a/compiler/rustc_resolve/messages.ftl b/compiler/rustc_resolve/messages.ftl
deleted file mode 100644
index 4a980b2bd747d..0000000000000
--- a/compiler/rustc_resolve/messages.ftl
+++ /dev/null
@@ -1,531 +0,0 @@
-resolve_accessible_unsure = not sure whether the path is accessible or not
-    .note = the type may have associated items, but we are currently not checking them
-
-resolve_add_as_non_derive =
-    add as non-Derive macro
-    `#[{$macro_path}]`
-
-resolve_added_macro_use =
-    have you added the `#[macro_use]` on the module/import?
-
-resolve_ancestor_only =
-    visibilities can only be restricted to ancestor modules
-
-resolve_anonymous_lifetime_non_gat_report_error = missing lifetime in associated type
-    .label = this lifetime must come from the implemented type
-    .note = in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
-
-resolve_arguments_macro_use_not_allowed = arguments to `macro_use` are not allowed here
-
-resolve_associated_const_with_similar_name_exists =
-    there is an associated constant with a similar name
-
-resolve_associated_fn_with_similar_name_exists =
-    there is an associated function with a similar name
-
-resolve_associated_type_with_similar_name_exists =
-    there is an associated type with a similar name
-
-resolve_attempt_to_use_non_constant_value_in_constant =
-    attempt to use a non-constant value in a constant
-
-resolve_attempt_to_use_non_constant_value_in_constant_label_with_suggestion =
-    non-constant value
-
-resolve_attempt_to_use_non_constant_value_in_constant_with_suggestion =
-    consider using `{$suggestion}` instead of `{$current}`
-
-resolve_attempt_to_use_non_constant_value_in_constant_without_suggestion =
-    this would need to be a `{$suggestion}`
-
-resolve_attributes_starting_with_rustc_are_reserved =
-    attributes starting with `rustc` are reserved for use by the `rustc` compiler
-
-resolve_binding_in_never_pattern =
-    never patterns cannot contain variable bindings
-    .suggestion = use a wildcard `_` instead
-
-resolve_binding_shadows_something_unacceptable =
-    {$shadowing_binding}s cannot shadow {$shadowed_binding}s
-    .label = cannot be named the same as {$article} {$shadowed_binding}
-    .label_shadowed_binding = the {$shadowed_binding} `{$name}` is {$participle} here
-
-resolve_binding_shadows_something_unacceptable_suggestion =
-    try specify the pattern arguments
-
-resolve_cannot_be_reexported_crate_public =
-    `{$ident}` is only public within the crate, and cannot be re-exported outside
-
-resolve_cannot_be_reexported_private =
-    `{$ident}` is private, and cannot be re-exported
-
-resolve_cannot_capture_dynamic_environment_in_fn_item =
-    can't capture dynamic environment in a fn item
-    .help = use the `|| {"{"} ... {"}"}` closure form instead
-
-resolve_cannot_determine_import_resolution =
-    cannot determine resolution for the import
-    .note = import resolution is stuck, try simplifying other imports
-
-resolve_cannot_determine_macro_resolution =
-    cannot determine resolution for the {$kind} `{$path}`
-    .note = import resolution is stuck, try simplifying macro imports
-
-resolve_cannot_find_builtin_macro_with_name =
-    cannot find a built-in macro with name `{$ident}`
-
-resolve_cannot_find_ident_in_this_scope =
-    cannot find {$expected} `{$ident}` in this scope
-
-resolve_cannot_glob_import_possible_crates =
-    cannot glob-import all possible crates
-
-resolve_cannot_use_through_an_import =
-    cannot use {$article} {$descr} through an import
-    .note = the {$descr} imported here
-
-resolve_change_import_binding =
-    you can use `as` to change the binding name of the import
-
-resolve_consider_adding_a_derive =
-    consider adding a derive
-
-resolve_consider_adding_macro_export =
-    consider adding a `#[macro_export]` to the macro in the imported module
-
-resolve_consider_declaring_with_pub =
-    consider declaring type or module `{$ident}` with `pub`
-
-resolve_consider_making_the_field_public =
-    { $number_of_fields ->
-        [one] consider making the field publicly accessible
-        *[other] consider making the fields publicly accessible
-    }
-
-resolve_consider_marking_as_pub =
-    consider marking `{$ident}` as `pub` in the imported module
-
-resolve_consider_marking_as_pub_crate =
-    in case you want to use the macro within this crate only, reduce the visibility to `pub(crate)`
-
-resolve_consider_move_macro_position =
-    consider moving the definition of `{$ident}` before this call
-
-
-resolve_const_not_member_of_trait =
-    const `{$const_}` is not a member of trait `{$trait_}`
-    .label = not a member of trait `{$trait_}`
-
-resolve_const_param_in_enum_discriminant =
-    const parameters may not be used in enum discriminant values
-
-resolve_const_param_in_non_trivial_anon_const =
-    const parameters may only be used as standalone arguments here, i.e. `{$name}`
-
-resolve_constructor_private_if_any_field_private =
-    a constructor is private if any of the fields is private
-
-resolve_elided_anonymous_lifetime_report_error =
-    `&` without an explicit lifetime name cannot be used here
-    .label = explicit lifetime name needed here
-
-resolve_elided_anonymous_lifetime_report_error_suggestion =
-    consider introducing a higher-ranked lifetime here
-
-resolve_expected_module_found =
-    expected module, found {$res} `{$path_str}`
-    .label = not a module
-
-resolve_explicit_anonymous_lifetime_report_error =
-    `'_` cannot be used here
-    .label = `'_` is a reserved lifetime name
-
-resolve_explicit_unsafe_traits =
-    unsafe traits like `{$ident}` should be implemented explicitly
-
-resolve_extern_crate_loading_macro_not_at_crate_root =
-    an `extern crate` loading macros must be at the crate root
-
-resolve_extern_crate_not_idiomatic = `extern crate` is not idiomatic in the new edition
-    .suggestion = convert it to a `use`
-
-resolve_extern_crate_self_requires_renaming =
-    `extern crate self;` requires renaming
-    .suggestion = rename the `self` crate to be able to import it
-
-resolve_forward_declared_generic_in_const_param_ty =
-    const parameter types cannot reference parameters before they are declared
-    .label = const parameter type cannot reference `{$param}` before it is declared
-
-resolve_forward_declared_generic_param =
-    generic parameter defaults cannot reference parameters before they are declared
-    .label = cannot reference `{$param}` before it is declared
-
-resolve_found_an_item_configured_out =
-    found an item that was configured out
-
-resolve_generic_arguments_in_macro_path =
-    generic arguments in macro path
-
-resolve_generic_params_from_outer_item =
-    can't use {$is_self ->
-        [true] `Self`
-        *[false] generic parameters
-    } from outer item
-    .label = use of {$is_self ->
-        [true] `Self`
-        *[false] generic parameter
-    } from outer item
-    .refer_to_type_directly = refer to the type directly here instead
-    .suggestion = try introducing a local generic parameter here
-    .note = nested items are independent from their parent item for everything except for privacy and name resolution
-
-resolve_generic_params_from_outer_item_const = a `const` is a separate item from the item that contains it
-
-resolve_generic_params_from_outer_item_const_param = const parameter from outer item
-
-resolve_generic_params_from_outer_item_inner_item = {$is_self ->
-        [true] `Self`
-        *[false] generic parameter
-    } used in this inner {$descr}
-
-resolve_generic_params_from_outer_item_self_ty_alias = `Self` type implicitly declared here, by this `impl`
-
-resolve_generic_params_from_outer_item_self_ty_param = can't use `Self` here
-
-resolve_generic_params_from_outer_item_static = a `static` is a separate item from the item that contains it
-
-resolve_generic_params_from_outer_item_ty_param = type parameter from outer item
-
-resolve_ident_bound_more_than_once_in_parameter_list =
-    identifier `{$identifier}` is bound more than once in this parameter list
-    .label = used as parameter more than once
-
-resolve_ident_bound_more_than_once_in_same_pattern =
-    identifier `{$identifier}` is bound more than once in the same pattern
-    .label = used in a pattern more than once
-
-resolve_ident_imported_here_but_it_is_desc =
-    `{$imported_ident}` is imported here, but it is {$imported_ident_desc}
-
-resolve_ident_in_scope_but_it_is_desc =
-    `{$imported_ident}` is in scope, but it is {$imported_ident_desc}
-
-resolve_implicit_elided_lifetimes_not_allowed_here = implicit elided lifetime not allowed here
-
-resolve_imported_crate = `$crate` may not be imported
-
-resolve_imported_macro_not_found = imported macro not found
-
-resolve_imports_cannot_refer_to =
-    imports cannot refer to {$what}
-
-resolve_indeterminate =
-    cannot determine resolution for the visibility
-
-resolve_invalid_asm_sym =
-    invalid `sym` operand
-    .label = is a local variable
-    .help = `sym` operands must refer to either a function or a static
-
-resolve_is_private =
-    {$ident_descr} `{$ident}` is private
-    .label = private {$ident_descr}
-
-resolve_item_was_behind_feature =
-    the item is gated behind the `{$feature}` feature
-
-resolve_item_was_cfg_out = the item is gated here
-
-resolve_label_with_similar_name_reachable =
-    a label with a similar name is reachable
-
-resolve_legacy_derive_helpers = derive helper attribute is used before it is introduced
-    .label = the attribute is introduced here
-
-resolve_lending_iterator_report_error =
-    associated type `Iterator::Item` is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
-    .note = you can't create an `Iterator` that borrows each `Item` from itself, but you can instead create a new type that borrows your existing type and implement `Iterator` for that new type
-
-resolve_lifetime_param_in_enum_discriminant =
-    lifetime parameters may not be used in enum discriminant values
-
-resolve_lifetime_param_in_non_trivial_anon_const =
-    lifetime parameters may not be used in const expressions
-
-resolve_lowercase_self =
-    attempt to use a non-constant value in a constant
-    .suggestion = try using `Self`
-
-resolve_macro_cannot_use_as_attr =
-    `{$ident}` exists, but has no `attr` rules
-
-resolve_macro_cannot_use_as_derive =
-     `{$ident}` exists, but has no `derive` rules
-
-resolve_macro_cannot_use_as_fn_like =
-    `{$ident}` exists, but has no rules for function-like invocation
-
-resolve_macro_defined_later =
-    a macro with the same name exists, but it appears later
-
-resolve_macro_expanded_extern_crate_cannot_shadow_extern_arguments =
-    macro-expanded `extern crate` items cannot shadow names passed with `--extern`
-
-resolve_macro_expanded_macro_exports_accessed_by_absolute_paths = macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
-    .note = the macro is defined here
-
-resolve_macro_expected_found =
-    expected {$expected}, found {$found} `{$macro_path}`
-    .label = not {$article} {$expected}
-
-resolve_macro_extern_deprecated =
-    `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
-    .help = try an outer attribute: `#[macro_use]`
-
-resolve_macro_is_private = macro `{$ident}` is private
-
-resolve_macro_rule_never_used = rule #{$n} of macro `{$name}` is never used
-
-resolve_macro_use_deprecated =
-    applying the `#[macro_use]` attribute to an `extern crate` item is deprecated
-    .help = remove it and import macros at use sites with a `use` item instead
-
-resolve_macro_use_extern_crate_self = `#[macro_use]` is not supported on `extern crate self`
-
-resolve_macro_use_name_already_in_use =
-    `{$name}` is already in scope
-    .note = macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560)
-
-resolve_method_not_member_of_trait =
-    method `{$method}` is not a member of trait `{$trait_}`
-    .label = not a member of trait `{$trait_}`
-
-resolve_missing_macro_rules_name = maybe you have forgotten to define a name for this `macro_rules!`
-
-resolve_module_only =
-    visibility must resolve to a module
-
-resolve_name_defined_multiple_time =
-    the name `{$name}` is defined multiple times
-    .note = `{$name}` must be defined only once in the {$descr} namespace of this {$container}
-
-resolve_name_defined_multiple_time_old_binding_definition =
-    previous definition of the {$old_kind} `{$name}` here
-
-resolve_name_defined_multiple_time_old_binding_import =
-    previous import of the {$old_kind} `{$name}` here
-
-resolve_name_defined_multiple_time_redefined =
-    `{$name}` redefined here
-
-resolve_name_defined_multiple_time_reimported =
-    `{$name}` reimported here
-
-resolve_name_is_already_used_as_generic_parameter =
-    the name `{$name}` is already used for a generic parameter in this item's generic parameters
-    .label = already used
-    .first_use_of_name = first use of `{$name}`
-
-resolve_name_reserved_in_attribute_namespace =
-    name `{$ident}` is reserved in attribute namespace
-
-resolve_note_and_refers_to_the_item_defined_here =
-    {$first ->
-        [true] {$dots ->
-            [true] the {$binding_descr} `{$binding_name}` is defined here...
-            *[false] the {$binding_descr} `{$binding_name}` is defined here
-        }
-        *[false] {$dots ->
-            [true] ...and refers to the {$binding_descr} `{$binding_name}` which is defined here...
-            *[false] ...and refers to the {$binding_descr} `{$binding_name}` which is defined here
-        }
-    }
-
-resolve_out_of_scope_macro_calls = cannot find macro `{$path}` in the current scope when looking from {$location}
-    .label = not found from {$location}
-    .help = import `macro_rules` with `use` to make it callable above its definition
-
-resolve_outer_ident_is_not_publicly_reexported =
-    {$outer_ident_descr} `{$outer_ident}` is not publicly re-exported
-
-resolve_param_in_enum_discriminant =
-    generic parameters may not be used in enum discriminant values
-    .label = cannot perform const operation using `{$name}`
-
-resolve_param_in_non_trivial_anon_const =
-    generic parameters may not be used in const operations
-    .label = cannot perform const operation using `{$name}`
-
-resolve_param_in_non_trivial_anon_const_help =
-    add `#![feature(generic_const_exprs)]` to allow generic const expressions
-
-resolve_param_in_ty_of_const_param =
-    the type of const parameters must not depend on other generic parameters
-    .label = the type must not depend on the parameter `{$name}`
-
-resolve_pattern_doesnt_bind_name = pattern doesn't bind `{$name}`
-
-resolve_private_extern_crate_reexport = extern crate `{$ident}` is private and cannot be re-exported
-    .suggestion = consider making the `extern crate` item publicly accessible
-
-resolve_proc_macro_derive_resolution_fallback = cannot find {$ns_descr} `{$ident}` in this scope
-    .label = names from parent modules are not accessible without an explicit import
-
-resolve_proc_macro_same_crate = can't use a procedural macro from the same crate that defines it
-    .help = you can define integration tests in a directory named `tests`
-
-resolve_redundant_import_visibility = glob import doesn't reexport anything with visibility `{$import_vis}` because no imported item is public enough
-    .note = the most public imported item is `{$max_vis}`
-    .help = reduce the glob import's visibility or increase visibility of imported items
-
-resolve_reexport_of_crate_public =
-    re-export of crate public `{$ident}`
-
-resolve_reexport_of_private =
-    re-export of private `{$ident}`
-
-resolve_reexport_private_dependency =
-    {$kind} `{$name}` from private dependency '{$krate}' is re-exported
-
-resolve_relative_2018 =
-    relative paths are not supported in visibilities in 2018 edition or later
-    .suggestion = try
-
-resolve_remove_surrounding_derive =
-    remove from the surrounding `derive()`
-
-resolve_remove_unnecessary_import = remove unnecessary import
-
-resolve_self_import_can_only_appear_once_in_the_list =
-    `self` import can only appear once in an import list
-    .label = can only appear once in an import list
-
-resolve_self_import_only_in_import_list_with_non_empty_prefix =
-    `self` import can only appear in an import list with a non-empty prefix
-    .label = can only appear in an import list with a non-empty prefix
-
-resolve_self_imports_only_allowed_within =
-    `self` imports are only allowed within a {"{"} {"}"} list
-
-resolve_self_imports_only_allowed_within_multipart_suggestion =
-    alternatively, use the multi-path `use` syntax to import `self`
-
-resolve_self_imports_only_allowed_within_suggestion =
-    consider importing the module directly
-
-resolve_self_in_const_generic_ty =
-    cannot use `Self` in const parameter type
-
-resolve_self_in_generic_param_default =
-    generic parameters cannot use `Self` in their defaults
-
-resolve_similarly_named_defined_here =
-    similarly named {$candidate_descr} `{$candidate}` defined here
-
-resolve_single_item_defined_here =
-    {$candidate_descr} `{$candidate}` defined here
-
-resolve_static_lifetime_is_reserved = invalid lifetime parameter name: `{$lifetime}`
-    .label = 'static is a reserved lifetime name
-
-resolve_suggestion_import_ident_directly =
-    import `{$ident}` directly
-
-resolve_suggestion_import_ident_through_reexport =
-    import `{$ident}` through the re-export
-
-resolve_tool_module_imported =
-    cannot use a tool module through an import
-    .note = the tool module imported here
-
-resolve_tool_only_accepts_identifiers =
-    `{$tool}` only accepts identifiers
-    .label = not an identifier
-
-resolve_tool_was_already_registered =
-    tool `{$tool}` was already registered
-    .label = already registered here
-
-resolve_trait_impl_duplicate =
-    duplicate definitions with name `{$name}`:
-    .label = duplicate definition
-    .old_span_label = previous definition here
-    .trait_item_span = item in trait
-
-resolve_trait_impl_mismatch =
-    item `{$name}` is an associated {$kind}, which doesn't match its trait `{$trait_path}`
-    .label = does not match trait
-    .trait_impl_mismatch_label_item = item in trait
-resolve_try_using_similarly_named_label =
-    try using similarly named label
-
-resolve_type_not_member_of_trait =
-    type `{$type_}` is not a member of trait `{$trait_}`
-    .label = not a member of trait `{$trait_}`
-
-resolve_type_param_in_enum_discriminant =
-    type parameters may not be used in enum discriminant values
-
-resolve_type_param_in_non_trivial_anon_const =
-    type parameters may not be used in const expressions
-
-resolve_undeclared_label =
-    use of undeclared label `{$name}`
-    .label = undeclared label `{$name}`
-
-resolve_underscore_lifetime_is_reserved = `'_` cannot be used here
-    .label = `'_` is a reserved lifetime name
-    .help = use another lifetime specifier
-
-resolve_unexpected_res_change_ty_to_const_param_sugg =
-    you might have meant to write a const parameter here
-
-resolve_unexpected_res_use_at_op_in_slice_pat_with_range_sugg =
-    if you meant to collect the rest of the slice in `{$ident}`, use the at operator
-
-resolve_unknown_diagnostic_attribute = unknown diagnostic attribute
-resolve_unknown_diagnostic_attribute_typo_sugg = an attribute with a similar name exists
-
-resolve_unnamed_crate_root_import =
-    crate root imports need to be explicitly named: `use crate as name;`
-
-resolve_unreachable_label =
-    use of unreachable label `{$name}`
-    .label = unreachable label `{$name}`
-    .label_definition_span = unreachable label defined here
-    .note = labels are unreachable through functions, closures, async blocks and modules
-
-resolve_unreachable_label_similar_name_reachable =
-    a label with a similar name is reachable
-
-resolve_unreachable_label_similar_name_unreachable =
-    a label with a similar name exists but is also unreachable
-
-resolve_unreachable_label_suggestion_use_similarly_named =
-    try using similarly named label
-
-resolve_unreachable_label_with_similar_name_exists =
-    a label with a similar name exists but is unreachable
-
-resolve_unused_extern_crate = unused extern crate
-    .label = unused
-    .suggestion = remove the unused `extern crate`
-
-resolve_unused_label = unused label
-
-resolve_unused_macro_definition = unused macro definition: `{$name}`
-
-resolve_unused_macro_use = unused `#[macro_use]` import
-
-resolve_variable_bound_with_different_mode =
-    variable `{$variable_name}` is bound inconsistently across alternatives separated by `|`
-    .label = bound in different ways
-    .first_binding_span = first binding
-
-resolve_variable_is_a_typo = you might have meant to use the similarly named previously used binding `{$typo}`
-
-resolve_variable_is_not_bound_in_all_patterns =
-    variable `{$name}` is not bound in all patterns
-
-resolve_variable_not_in_all_patterns = variable not in all patterns
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 3e54464030527..7afdbf6a469f8 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -1,21 +1,31 @@
 use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, DiagCtxtHandle, DiagMessage, Diagnostic, ElidedLifetimeInPathSubdiag,
-    EmissionGuarantee, IntoDiagArg, Level, LintDiagnostic, MultiSpan, Subdiagnostic,
+    EmissionGuarantee, IntoDiagArg, Level, LintDiagnostic, MultiSpan, Subdiagnostic, inline_fluent,
 };
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_span::source_map::Spanned;
 use rustc_span::{Ident, Span, Symbol};
 
+use crate::Res;
 use crate::late::PatternSource;
-use crate::{Res, fluent_generated as fluent};
 
 #[derive(Diagnostic)]
-#[diag(resolve_generic_params_from_outer_item, code = E0401)]
-#[note]
+#[diag("can't use {$is_self ->
+        [true] `Self`
+        *[false] generic parameters
+    } from outer item", code = E0401)]
+#[note(
+    "nested items are independent from their parent item for everything except for privacy and name resolution"
+)]
 pub(crate) struct GenericParamsFromOuterItem {
     #[primary_span]
-    #[label]
+    #[label(
+        "use of {$is_self ->
+            [true] `Self`
+            *[false] generic parameter
+        } from outer item"
+    )]
     pub(crate) span: Span,
     #[subdiagnostic]
     pub(crate) label: Option<GenericParamsFromOuterItemLabel>,
@@ -31,7 +41,12 @@ pub(crate) struct GenericParamsFromOuterItem {
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_generic_params_from_outer_item_inner_item)]
+#[label(
+    "{$is_self ->
+        [true] `Self`
+        *[false] generic parameter
+    } used in this inner {$descr}"
+)]
 pub(crate) struct GenericParamsFromOuterItemInnerItem {
     #[primary_span]
     pub(crate) span: Span,
@@ -40,27 +55,27 @@ pub(crate) struct GenericParamsFromOuterItemInnerItem {
 
 #[derive(Subdiagnostic)]
 pub(crate) enum GenericParamsFromOuterItemStaticOrConst {
-    #[note(resolve_generic_params_from_outer_item_static)]
+    #[note("a `static` is a separate item from the item that contains it")]
     Static,
-    #[note(resolve_generic_params_from_outer_item_const)]
+    #[note("a `const` is a separate item from the item that contains it")]
     Const,
 }
 
 #[derive(Subdiagnostic)]
 pub(crate) enum GenericParamsFromOuterItemLabel {
-    #[label(resolve_generic_params_from_outer_item_self_ty_param)]
+    #[label("can't use `Self` here")]
     SelfTyParam(#[primary_span] Span),
-    #[label(resolve_generic_params_from_outer_item_self_ty_alias)]
+    #[label("`Self` type implicitly declared here, by this `impl`")]
     SelfTyAlias(#[primary_span] Span),
-    #[label(resolve_generic_params_from_outer_item_ty_param)]
+    #[label("type parameter from outer item")]
     TyParam(#[primary_span] Span),
-    #[label(resolve_generic_params_from_outer_item_const_param)]
+    #[label("const parameter from outer item")]
     ConstParam(#[primary_span] Span),
 }
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_suggestion,
+    "try introducing a local generic parameter here",
     code = "{snippet}",
     applicability = "maybe-incorrect",
     style = "verbose"
@@ -72,7 +87,7 @@ pub(crate) struct GenericParamsFromOuterItemSugg {
 }
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_refer_to_type_directly,
+    "refer to the type directly here instead",
     code = "{snippet}",
     applicability = "maybe-incorrect",
     style = "verbose"
@@ -84,21 +99,21 @@ pub(crate) struct UseTypeDirectly {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_name_is_already_used_as_generic_parameter, code = E0403)]
+#[diag("the name `{$name}` is already used for a generic parameter in this item's generic parameters", code = E0403)]
 pub(crate) struct NameAlreadyUsedInParameterList {
     #[primary_span]
-    #[label]
+    #[label("already used")]
     pub(crate) span: Span,
-    #[label(resolve_first_use_of_name)]
+    #[label("first use of `{$name}`")]
     pub(crate) first_use_span: Span,
     pub(crate) name: Ident,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_method_not_member_of_trait, code = E0407)]
+#[diag("method `{$method}` is not a member of trait `{$trait_}`", code = E0407)]
 pub(crate) struct MethodNotMemberOfTrait {
     #[primary_span]
-    #[label]
+    #[label("not a member of trait `{$trait_}`")]
     pub(crate) span: Span,
     pub(crate) method: Ident,
     pub(crate) trait_: String,
@@ -108,7 +123,7 @@ pub(crate) struct MethodNotMemberOfTrait {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_associated_fn_with_similar_name_exists,
+    "there is an associated function with a similar name",
     code = "{candidate}",
     applicability = "maybe-incorrect"
 )]
@@ -119,10 +134,10 @@ pub(crate) struct AssociatedFnWithSimilarNameExists {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_type_not_member_of_trait, code = E0437)]
+#[diag("type `{$type_}` is not a member of trait `{$trait_}`", code = E0437)]
 pub(crate) struct TypeNotMemberOfTrait {
     #[primary_span]
-    #[label]
+    #[label("not a member of trait `{$trait_}`")]
     pub(crate) span: Span,
     pub(crate) type_: Ident,
     pub(crate) trait_: String,
@@ -132,7 +147,7 @@ pub(crate) struct TypeNotMemberOfTrait {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_associated_type_with_similar_name_exists,
+    "there is an associated type with a similar name",
     code = "{candidate}",
     applicability = "maybe-incorrect"
 )]
@@ -143,10 +158,10 @@ pub(crate) struct AssociatedTypeWithSimilarNameExists {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_const_not_member_of_trait, code = E0438)]
+#[diag("const `{$const_}` is not a member of trait `{$trait_}`", code = E0438)]
 pub(crate) struct ConstNotMemberOfTrait {
     #[primary_span]
-    #[label]
+    #[label("not a member of trait `{$trait_}`")]
     pub(crate) span: Span,
     pub(crate) const_: Ident,
     pub(crate) trait_: String,
@@ -156,7 +171,7 @@ pub(crate) struct ConstNotMemberOfTrait {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_associated_const_with_similar_name_exists,
+    "there is an associated constant with a similar name",
     code = "{candidate}",
     applicability = "maybe-incorrect"
 )]
@@ -167,39 +182,39 @@ pub(crate) struct AssociatedConstWithSimilarNameExists {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_variable_bound_with_different_mode, code = E0409)]
+#[diag("variable `{$variable_name}` is bound inconsistently across alternatives separated by `|`", code = E0409)]
 pub(crate) struct VariableBoundWithDifferentMode {
     #[primary_span]
-    #[label]
+    #[label("bound in different ways")]
     pub(crate) span: Span,
-    #[label(resolve_first_binding_span)]
+    #[label("first binding")]
     pub(crate) first_binding_span: Span,
     pub(crate) variable_name: Ident,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_ident_bound_more_than_once_in_parameter_list, code = E0415)]
+#[diag("identifier `{$identifier}` is bound more than once in this parameter list", code = E0415)]
 pub(crate) struct IdentifierBoundMoreThanOnceInParameterList {
     #[primary_span]
-    #[label]
+    #[label("used as parameter more than once")]
     pub(crate) span: Span,
     pub(crate) identifier: Ident,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_ident_bound_more_than_once_in_same_pattern, code = E0416)]
+#[diag("identifier `{$identifier}` is bound more than once in the same pattern", code = E0416)]
 pub(crate) struct IdentifierBoundMoreThanOnceInSamePattern {
     #[primary_span]
-    #[label]
+    #[label("used in a pattern more than once")]
     pub(crate) span: Span,
     pub(crate) identifier: Ident,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_undeclared_label, code = E0426)]
+#[diag("use of undeclared label `{$name}`", code = E0426)]
 pub(crate) struct UndeclaredLabel {
     #[primary_span]
-    #[label]
+    #[label("undeclared label `{$name}`")]
     pub(crate) span: Span,
     pub(crate) name: Symbol,
     #[subdiagnostic]
@@ -211,12 +226,12 @@ pub(crate) struct UndeclaredLabel {
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_label_with_similar_name_reachable)]
+#[label("a label with a similar name is reachable")]
 pub(crate) struct LabelWithSimilarNameReachable(#[primary_span] pub(crate) Span);
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_try_using_similarly_named_label,
+    "try using similarly named label",
     code = "{ident_name}",
     applicability = "maybe-incorrect"
 )]
@@ -227,38 +242,38 @@ pub(crate) struct TryUsingSimilarlyNamedLabel {
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_unreachable_label_with_similar_name_exists)]
+#[label("a label with a similar name exists but is unreachable")]
 pub(crate) struct UnreachableLabelWithSimilarNameExists {
     #[primary_span]
     pub(crate) ident_span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_self_import_can_only_appear_once_in_the_list, code = E0430)]
+#[diag("`self` import can only appear once in an import list", code = E0430)]
 pub(crate) struct SelfImportCanOnlyAppearOnceInTheList {
     #[primary_span]
-    #[label]
+    #[label("can only appear once in an import list")]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_self_import_only_in_import_list_with_non_empty_prefix, code = E0431)]
+#[diag("`self` import can only appear in an import list with a non-empty prefix", code = E0431)]
 pub(crate) struct SelfImportOnlyInImportListWithNonEmptyPrefix {
     #[primary_span]
-    #[label]
+    #[label("can only appear in an import list with a non-empty prefix")]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_capture_dynamic_environment_in_fn_item, code = E0434)]
-#[help]
+#[diag("can't capture dynamic environment in a fn item", code = E0434)]
+#[help("use the `|| {\"{\"} ... {\"}\"}` closure form instead")]
 pub(crate) struct CannotCaptureDynamicEnvironmentInFnItem {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_attempt_to_use_non_constant_value_in_constant, code = E0435)]
+#[diag("attempt to use a non-constant value in a constant", code = E0435)]
 pub(crate) struct AttemptToUseNonConstantValueInConstant<'a> {
     #[primary_span]
     pub(crate) span: Span,
@@ -272,7 +287,7 @@ pub(crate) struct AttemptToUseNonConstantValueInConstant<'a> {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    resolve_attempt_to_use_non_constant_value_in_constant_with_suggestion,
+    "consider using `{$suggestion}` instead of `{$current}`",
     style = "verbose",
     applicability = "has-placeholders"
 )]
@@ -287,14 +302,14 @@ pub(crate) struct AttemptToUseNonConstantValueInConstantWithSuggestion<'a> {
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_attempt_to_use_non_constant_value_in_constant_label_with_suggestion)]
+#[label("non-constant value")]
 pub(crate) struct AttemptToUseNonConstantValueInConstantLabelWithSuggestion {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_attempt_to_use_non_constant_value_in_constant_without_suggestion)]
+#[label("this would need to be a `{$suggestion}`")]
 pub(crate) struct AttemptToUseNonConstantValueInConstantWithoutSuggestion<'a> {
     #[primary_span]
     pub(crate) ident_span: Span,
@@ -302,7 +317,7 @@ pub(crate) struct AttemptToUseNonConstantValueInConstantWithoutSuggestion<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_self_imports_only_allowed_within, code = E0429)]
+#[diag("`self` imports are only allowed within a {\"{\"} {\"}\"} list", code = E0429)]
 pub(crate) struct SelfImportsOnlyAllowedWithin {
     #[primary_span]
     pub(crate) span: Span,
@@ -314,7 +329,7 @@ pub(crate) struct SelfImportsOnlyAllowedWithin {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_self_imports_only_allowed_within_suggestion,
+    "consider importing the module directly",
     code = "",
     applicability = "machine-applicable"
 )]
@@ -325,7 +340,7 @@ pub(crate) struct SelfImportsOnlyAllowedWithinSuggestion {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    resolve_self_imports_only_allowed_within_multipart_suggestion,
+    "alternatively, use the multi-path `use` syntax to import `self`",
     applicability = "machine-applicable"
 )]
 pub(crate) struct SelfImportsOnlyAllowedWithinMultipartSuggestion {
@@ -336,17 +351,17 @@ pub(crate) struct SelfImportsOnlyAllowedWithinMultipartSuggestion {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_binding_shadows_something_unacceptable, code = E0530)]
+#[diag("{$shadowing_binding}s cannot shadow {$shadowed_binding}s", code = E0530)]
 pub(crate) struct BindingShadowsSomethingUnacceptable<'a> {
     #[primary_span]
-    #[label]
+    #[label("cannot be named the same as {$article} {$shadowed_binding}")]
     pub(crate) span: Span,
     pub(crate) shadowing_binding: PatternSource,
     pub(crate) shadowed_binding: Res,
     pub(crate) article: &'a str,
     #[subdiagnostic]
     pub(crate) sub_suggestion: Option<BindingShadowsSomethingUnacceptableSuggestion>,
-    #[label(resolve_label_shadowed_binding)]
+    #[label("the {$shadowed_binding} `{$name}` is {$participle} here")]
     pub(crate) shadowed_binding_span: Span,
     pub(crate) participle: &'a str,
     pub(crate) name: Symbol,
@@ -354,7 +369,7 @@ pub(crate) struct BindingShadowsSomethingUnacceptable<'a> {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_binding_shadows_something_unacceptable_suggestion,
+    "try specify the pattern arguments",
     code = "{name}(..)",
     applicability = "unspecified"
 )]
@@ -365,51 +380,51 @@ pub(crate) struct BindingShadowsSomethingUnacceptableSuggestion {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_forward_declared_generic_param, code = E0128)]
+#[diag("generic parameter defaults cannot reference parameters before they are declared", code = E0128)]
 pub(crate) struct ForwardDeclaredGenericParam {
     #[primary_span]
-    #[label]
+    #[label("cannot reference `{$param}` before it is declared")]
     pub(crate) span: Span,
     pub(crate) param: Symbol,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_forward_declared_generic_in_const_param_ty)]
+#[diag("const parameter types cannot reference parameters before they are declared")]
 pub(crate) struct ForwardDeclaredGenericInConstParamTy {
     #[primary_span]
-    #[label]
+    #[label("const parameter type cannot reference `{$param}` before it is declared")]
     pub(crate) span: Span,
     pub(crate) param: Symbol,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_param_in_ty_of_const_param, code = E0770)]
+#[diag("the type of const parameters must not depend on other generic parameters", code = E0770)]
 pub(crate) struct ParamInTyOfConstParam {
     #[primary_span]
-    #[label]
+    #[label("the type must not depend on the parameter `{$name}`")]
     pub(crate) span: Span,
     pub(crate) name: Symbol,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_self_in_generic_param_default, code = E0735)]
+#[diag("generic parameters cannot use `Self` in their defaults", code = E0735)]
 pub(crate) struct SelfInGenericParamDefault {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_self_in_const_generic_ty)]
+#[diag("cannot use `Self` in const parameter type")]
 pub(crate) struct SelfInConstGenericTy {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_param_in_non_trivial_anon_const)]
+#[diag("generic parameters may not be used in const operations")]
 pub(crate) struct ParamInNonTrivialAnonConst {
     #[primary_span]
-    #[label]
+    #[label("cannot perform const operation using `{$name}`")]
     pub(crate) span: Span,
     pub(crate) name: Symbol,
     #[subdiagnostic]
@@ -419,29 +434,29 @@ pub(crate) struct ParamInNonTrivialAnonConst {
 }
 
 #[derive(Subdiagnostic)]
-#[help(resolve_param_in_non_trivial_anon_const_help)]
+#[help("add `#![feature(generic_const_exprs)]` to allow generic const expressions")]
 pub(crate) struct ParamInNonTrivialAnonConstHelp;
 
 #[derive(Debug)]
 #[derive(Subdiagnostic)]
 pub(crate) enum ParamKindInNonTrivialAnonConst {
-    #[note(resolve_type_param_in_non_trivial_anon_const)]
+    #[note("type parameters may not be used in const expressions")]
     Type,
-    #[help(resolve_const_param_in_non_trivial_anon_const)]
+    #[help("const parameters may only be used as standalone arguments here, i.e. `{$name}`")]
     Const { name: Symbol },
-    #[note(resolve_lifetime_param_in_non_trivial_anon_const)]
+    #[note("lifetime parameters may not be used in const expressions")]
     Lifetime,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_unreachable_label, code = E0767)]
-#[note]
+#[diag("use of unreachable label `{$name}`", code = E0767)]
+#[note("labels are unreachable through functions, closures, async blocks and modules")]
 pub(crate) struct UnreachableLabel {
     #[primary_span]
-    #[label]
+    #[label("unreachable label `{$name}`")]
     pub(crate) span: Span,
     pub(crate) name: Symbol,
-    #[label(resolve_label_definition_span)]
+    #[label("unreachable label defined here")]
     pub(crate) definition_span: Span,
     #[subdiagnostic]
     pub(crate) sub_suggestion: Option<UnreachableLabelSubSuggestion>,
@@ -453,7 +468,7 @@ pub(crate) struct UnreachableLabel {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_unreachable_label_suggestion_use_similarly_named,
+    "try using similarly named label",
     code = "{ident_name}",
     applicability = "maybe-incorrect"
 )]
@@ -464,104 +479,114 @@ pub(crate) struct UnreachableLabelSubSuggestion {
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_unreachable_label_similar_name_reachable)]
+#[label("a label with a similar name is reachable")]
 pub(crate) struct UnreachableLabelSubLabel {
     #[primary_span]
     pub(crate) ident_span: Span,
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_unreachable_label_similar_name_unreachable)]
+#[label("a label with a similar name exists but is also unreachable")]
 pub(crate) struct UnreachableLabelSubLabelUnreachable {
     #[primary_span]
     pub(crate) ident_span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_invalid_asm_sym)]
-#[help]
+#[diag("invalid `sym` operand")]
+#[help("`sym` operands must refer to either a function or a static")]
 pub(crate) struct InvalidAsmSym {
     #[primary_span]
-    #[label]
+    #[label("is a local variable")]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_lowercase_self)]
+#[diag("attempt to use a non-constant value in a constant")]
 pub(crate) struct LowercaseSelf {
     #[primary_span]
-    #[suggestion(code = "Self", applicability = "maybe-incorrect", style = "short")]
+    #[suggestion(
+        "try using `Self`",
+        code = "Self",
+        applicability = "maybe-incorrect",
+        style = "short"
+    )]
     pub(crate) span: Span,
 }
 
 #[derive(Debug)]
 #[derive(Diagnostic)]
-#[diag(resolve_binding_in_never_pattern)]
+#[diag("never patterns cannot contain variable bindings")]
 pub(crate) struct BindingInNeverPattern {
     #[primary_span]
-    #[suggestion(code = "_", applicability = "machine-applicable", style = "short")]
+    #[suggestion(
+        "use a wildcard `_` instead",
+        code = "_",
+        applicability = "machine-applicable",
+        style = "short"
+    )]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_trait_impl_duplicate, code = E0201)]
+#[diag("duplicate definitions with name `{$name}`:", code = E0201)]
 pub(crate) struct TraitImplDuplicate {
     #[primary_span]
-    #[label]
+    #[label("duplicate definition")]
     pub(crate) span: Span,
-    #[label(resolve_old_span_label)]
+    #[label("previous definition here")]
     pub(crate) old_span: Span,
-    #[label(resolve_trait_item_span)]
+    #[label("item in trait")]
     pub(crate) trait_item_span: Span,
     pub(crate) name: Ident,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_relative_2018)]
+#[diag("relative paths are not supported in visibilities in 2018 edition or later")]
 pub(crate) struct Relative2018 {
     #[primary_span]
     pub(crate) span: Span,
-    #[suggestion(code = "crate::{path_str}", applicability = "maybe-incorrect")]
+    #[suggestion("try", code = "crate::{path_str}", applicability = "maybe-incorrect")]
     pub(crate) path_span: Span,
     pub(crate) path_str: String,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_ancestor_only, code = E0742)]
+#[diag("visibilities can only be restricted to ancestor modules", code = E0742)]
 pub(crate) struct AncestorOnly(#[primary_span] pub(crate) Span);
 
 #[derive(Diagnostic)]
-#[diag(resolve_expected_module_found, code = E0577)]
+#[diag("expected module, found {$res} `{$path_str}`", code = E0577)]
 pub(crate) struct ExpectedModuleFound {
     #[primary_span]
-    #[label]
+    #[label("not a module")]
     pub(crate) span: Span,
     pub(crate) res: Res,
     pub(crate) path_str: String,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_indeterminate, code = E0578)]
+#[diag("cannot determine resolution for the visibility", code = E0578)]
 pub(crate) struct Indeterminate(#[primary_span] pub(crate) Span);
 
 #[derive(Diagnostic)]
-#[diag(resolve_tool_module_imported)]
+#[diag("cannot use a tool module through an import")]
 pub(crate) struct ToolModuleImported {
     #[primary_span]
     pub(crate) span: Span,
-    #[note]
+    #[note("the tool module imported here")]
     pub(crate) import: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_module_only)]
+#[diag("visibility must resolve to a module")]
 pub(crate) struct ModuleOnly(#[primary_span] pub(crate) Span);
 
 #[derive(Diagnostic)]
-#[diag(resolve_macro_expected_found)]
+#[diag("expected {$expected}, found {$found} `{$macro_path}`")]
 pub(crate) struct MacroExpectedFound<'a> {
     #[primary_span]
-    #[label]
+    #[label("not {$article} {$expected}")]
     pub(crate) span: Span,
     pub(crate) found: &'a str,
     pub(crate) article: &'static str,
@@ -574,60 +599,66 @@ pub(crate) struct MacroExpectedFound<'a> {
 }
 
 #[derive(Subdiagnostic)]
-#[help(resolve_remove_surrounding_derive)]
+#[help("remove from the surrounding `derive()`")]
 pub(crate) struct RemoveSurroundingDerive {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Subdiagnostic)]
-#[help(resolve_add_as_non_derive)]
+#[help(
+    "
+    add as non-Derive macro
+    `#[{$macro_path}]`"
+)]
 pub(crate) struct AddAsNonDerive<'a> {
     pub(crate) macro_path: &'a str,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_proc_macro_same_crate)]
+#[diag("can't use a procedural macro from the same crate that defines it")]
 pub(crate) struct ProcMacroSameCrate {
     #[primary_span]
     pub(crate) span: Span,
-    #[help]
+    #[help("you can define integration tests in a directory named `tests`")]
     pub(crate) is_test: bool,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_proc_macro_derive_resolution_fallback)]
+#[diag("cannot find {$ns_descr} `{$ident}` in this scope")]
 pub(crate) struct ProcMacroDeriveResolutionFallback {
-    #[label]
+    #[label("names from parent modules are not accessible without an explicit import")]
     pub span: Span,
     pub ns_descr: &'static str,
     pub ident: Symbol,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_macro_expanded_macro_exports_accessed_by_absolute_paths)]
+#[diag(
+    "macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths"
+)]
 pub(crate) struct MacroExpandedMacroExportsAccessedByAbsolutePaths {
-    #[note]
+    #[note("the macro is defined here")]
     pub definition: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_imported_crate)]
+#[diag("`$crate` may not be imported")]
 pub(crate) struct CrateImported {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_macro_use_extern_crate_self)]
+#[diag("`#[macro_use]` is not supported on `extern crate self`")]
 pub(crate) struct MacroUseExternCrateSelf {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_accessible_unsure)]
-#[note]
+#[diag("not sure whether the path is accessible or not")]
+#[note("the type may have associated items, but we are currently not checking them")]
 pub(crate) struct CfgAccessibleUnsure {
     #[primary_span]
     pub(crate) span: Span,
@@ -635,10 +666,10 @@ pub(crate) struct CfgAccessibleUnsure {
 
 #[derive(Debug)]
 #[derive(Diagnostic)]
-#[diag(resolve_param_in_enum_discriminant)]
+#[diag("generic parameters may not be used in enum discriminant values")]
 pub(crate) struct ParamInEnumDiscriminant {
     #[primary_span]
-    #[label]
+    #[label("cannot perform const operation using `{$name}`")]
     pub(crate) span: Span,
     pub(crate) name: Symbol,
     #[subdiagnostic]
@@ -648,16 +679,16 @@ pub(crate) struct ParamInEnumDiscriminant {
 #[derive(Debug)]
 #[derive(Subdiagnostic)]
 pub(crate) enum ParamKindInEnumDiscriminant {
-    #[note(resolve_type_param_in_enum_discriminant)]
+    #[note("type parameters may not be used in enum discriminant values")]
     Type,
-    #[note(resolve_const_param_in_enum_discriminant)]
+    #[note("const parameters may not be used in enum discriminant values")]
     Const,
-    #[note(resolve_lifetime_param_in_enum_discriminant)]
+    #[note("lifetime parameters may not be used in enum discriminant values")]
     Lifetime,
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_change_import_binding)]
+#[label("you can use `as` to change the binding name of the import")]
 pub(crate) struct ChangeImportBinding {
     #[primary_span]
     pub(crate) span: Span,
@@ -665,7 +696,7 @@ pub(crate) struct ChangeImportBinding {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_change_import_binding,
+    "you can use `as` to change the binding name of the import",
     code = "{suggestion}",
     applicability = "maybe-incorrect"
 )]
@@ -676,7 +707,7 @@ pub(crate) struct ChangeImportBindingSuggestion {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_imports_cannot_refer_to)]
+#[diag("imports cannot refer to {$what}")]
 pub(crate) struct ImportsCannotReferTo<'a> {
     #[primary_span]
     pub(crate) span: Span,
@@ -684,7 +715,7 @@ pub(crate) struct ImportsCannotReferTo<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_find_ident_in_this_scope)]
+#[diag("cannot find {$expected} `{$ident}` in this scope")]
 pub(crate) struct CannotFindIdentInThisScope<'a> {
     #[primary_span]
     pub(crate) span: Span,
@@ -693,7 +724,7 @@ pub(crate) struct CannotFindIdentInThisScope<'a> {
 }
 
 #[derive(Subdiagnostic)]
-#[note(resolve_explicit_unsafe_traits)]
+#[note("unsafe traits like `{$ident}` should be implemented explicitly")]
 pub(crate) struct ExplicitUnsafeTraits {
     #[primary_span]
     pub(crate) span: Span,
@@ -701,14 +732,14 @@ pub(crate) struct ExplicitUnsafeTraits {
 }
 
 #[derive(Subdiagnostic)]
-#[note(resolve_macro_defined_later)]
+#[note("a macro with the same name exists, but it appears later")]
 pub(crate) struct MacroDefinedLater {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_consider_move_macro_position)]
+#[label("consider moving the definition of `{$ident}` before this call")]
 pub(crate) struct MacroSuggMovePosition {
     #[primary_span]
     pub(crate) span: Span,
@@ -717,19 +748,19 @@ pub(crate) struct MacroSuggMovePosition {
 
 #[derive(Subdiagnostic)]
 pub(crate) enum MacroRulesNot {
-    #[label(resolve_macro_cannot_use_as_fn_like)]
+    #[label("`{$ident}` exists, but has no rules for function-like invocation")]
     Func {
         #[primary_span]
         span: Span,
         ident: Ident,
     },
-    #[label(resolve_macro_cannot_use_as_attr)]
+    #[label("`{$ident}` exists, but has no `attr` rules")]
     Attr {
         #[primary_span]
         span: Span,
         ident: Ident,
     },
-    #[label(resolve_macro_cannot_use_as_derive)]
+    #[label("`{$ident}` exists, but has no `derive` rules")]
     Derive {
         #[primary_span]
         span: Span,
@@ -738,22 +769,18 @@ pub(crate) enum MacroRulesNot {
 }
 
 #[derive(Subdiagnostic)]
-#[note(resolve_missing_macro_rules_name)]
+#[note("maybe you have forgotten to define a name for this `macro_rules!`")]
 pub(crate) struct MaybeMissingMacroRulesName {
     #[primary_span]
     pub(crate) spans: MultiSpan,
 }
 
 #[derive(Subdiagnostic)]
-#[help(resolve_added_macro_use)]
+#[help("have you added the `#[macro_use]` on the module/import?")]
 pub(crate) struct AddedMacroUse;
 
 #[derive(Subdiagnostic)]
-#[suggestion(
-    resolve_consider_adding_a_derive,
-    code = "{suggestion}",
-    applicability = "maybe-incorrect"
-)]
+#[suggestion("consider adding a derive", code = "{suggestion}", applicability = "maybe-incorrect")]
 pub(crate) struct ConsiderAddingADerive {
     #[primary_span]
     pub(crate) span: Span,
@@ -761,15 +788,15 @@ pub(crate) struct ConsiderAddingADerive {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_determine_import_resolution)]
+#[diag("cannot determine resolution for the import")]
 pub(crate) struct CannotDetermineImportResolution {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_determine_macro_resolution)]
-#[note]
+#[diag("cannot determine resolution for the {$kind} `{$path}`")]
+#[note("import resolution is stuck, try simplifying macro imports")]
 pub(crate) struct CannotDetermineMacroResolution {
     #[primary_span]
     pub(crate) span: Span,
@@ -778,7 +805,7 @@ pub(crate) struct CannotDetermineMacroResolution {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_be_reexported_private, code = E0364)]
+#[diag("`{$ident}` is private, and cannot be re-exported", code = E0364)]
 pub(crate) struct CannotBeReexportedPrivate {
     #[primary_span]
     pub(crate) span: Span,
@@ -786,7 +813,7 @@ pub(crate) struct CannotBeReexportedPrivate {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_be_reexported_crate_public, code = E0364)]
+#[diag("`{$ident}` is only public within the crate, and cannot be re-exported outside", code = E0364)]
 pub(crate) struct CannotBeReexportedCratePublic {
     #[primary_span]
     pub(crate) span: Span,
@@ -794,35 +821,40 @@ pub(crate) struct CannotBeReexportedCratePublic {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_be_reexported_private, code = E0365)]
-#[note(resolve_consider_declaring_with_pub)]
+#[diag("`{$ident}` is private, and cannot be re-exported", code = E0365)]
+#[note("consider declaring type or module `{$ident}` with `pub`")]
 pub(crate) struct CannotBeReexportedPrivateNS {
     #[primary_span]
-    #[label(resolve_reexport_of_private)]
+    #[label("re-export of private `{$ident}`")]
     pub(crate) span: Span,
     pub(crate) ident: Ident,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_be_reexported_crate_public, code = E0365)]
-#[note(resolve_consider_declaring_with_pub)]
+#[diag("`{$ident}` is only public within the crate, and cannot be re-exported outside", code = E0365)]
+#[note("consider declaring type or module `{$ident}` with `pub`")]
 pub(crate) struct CannotBeReexportedCratePublicNS {
     #[primary_span]
-    #[label(resolve_reexport_of_crate_public)]
+    #[label("re-export of crate public `{$ident}`")]
     pub(crate) span: Span,
     pub(crate) ident: Ident,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_private_extern_crate_reexport, code = E0365)]
+#[diag("extern crate `{$ident}` is private and cannot be re-exported", code = E0365)]
 pub(crate) struct PrivateExternCrateReexport {
     pub ident: Ident,
-    #[suggestion(code = "pub ", style = "verbose", applicability = "maybe-incorrect")]
+    #[suggestion(
+        "consider making the `extern crate` item publicly accessible",
+        code = "pub ",
+        style = "verbose",
+        applicability = "maybe-incorrect"
+    )]
     pub sugg: Span,
 }
 
 #[derive(Subdiagnostic)]
-#[help(resolve_consider_adding_macro_export)]
+#[help("consider adding a `#[macro_export]` to the macro in the imported module")]
 pub(crate) struct ConsiderAddingMacroExport {
     #[primary_span]
     pub(crate) span: Span,
@@ -830,7 +862,7 @@ pub(crate) struct ConsiderAddingMacroExport {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_consider_marking_as_pub_crate,
+    "in case you want to use the macro within this crate only, reduce the visibility to `pub(crate)`",
     code = "pub(crate)",
     applicability = "maybe-incorrect"
 )]
@@ -840,7 +872,7 @@ pub(crate) struct ConsiderMarkingAsPubCrate {
 }
 
 #[derive(Subdiagnostic)]
-#[note(resolve_consider_marking_as_pub)]
+#[note("consider marking `{$ident}` as `pub` in the imported module")]
 pub(crate) struct ConsiderMarkingAsPub {
     #[primary_span]
     pub(crate) span: Span,
@@ -848,7 +880,7 @@ pub(crate) struct ConsiderMarkingAsPub {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_glob_import_possible_crates)]
+#[diag("cannot glob-import all possible crates")]
 pub(crate) struct CannotGlobImportAllCrates {
     #[primary_span]
     pub(crate) span: Span,
@@ -856,7 +888,7 @@ pub(crate) struct CannotGlobImportAllCrates {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_unexpected_res_change_ty_to_const_param_sugg,
+    "you might have meant to write a const parameter here",
     code = "const ",
     style = "verbose"
 )]
@@ -869,7 +901,7 @@ pub(crate) struct UnexpectedResChangeTyToConstParamSugg {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    resolve_unexpected_res_change_ty_to_const_param_sugg,
+    "you might have meant to write a const parameter here",
     applicability = "has-placeholders",
     style = "verbose"
 )]
@@ -882,7 +914,7 @@ pub(crate) struct UnexpectedResChangeTyParamToConstParamSugg {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_unexpected_res_use_at_op_in_slice_pat_with_range_sugg,
+    "if you meant to collect the rest of the slice in `{$ident}`, use the at operator",
     code = "{snippet}",
     applicability = "maybe-incorrect",
     style = "verbose"
@@ -895,23 +927,27 @@ pub(crate) struct UnexpectedResUseAtOpInSlicePatWithRangeSugg {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_extern_crate_loading_macro_not_at_crate_root, code = E0468)]
+#[diag("an `extern crate` loading macros must be at the crate root", code = E0468)]
 pub(crate) struct ExternCrateLoadingMacroNotAtCrateRoot {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_extern_crate_self_requires_renaming)]
+#[diag("`extern crate self;` requires renaming")]
 pub(crate) struct ExternCrateSelfRequiresRenaming {
     #[primary_span]
-    #[suggestion(code = "extern crate self as name;", applicability = "has-placeholders")]
+    #[suggestion(
+        "rename the `self` crate to be able to import it",
+        code = "extern crate self as name;",
+        applicability = "has-placeholders"
+    )]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_macro_use_name_already_in_use)]
-#[note]
+#[diag("`{$name}` is already in scope")]
+#[note("macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560)")]
 pub(crate) struct MacroUseNameAlreadyInUse {
     #[primary_span]
     pub(crate) span: Span,
@@ -919,74 +955,80 @@ pub(crate) struct MacroUseNameAlreadyInUse {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_imported_macro_not_found, code = E0469)]
+#[diag("imported macro not found", code = E0469)]
 pub(crate) struct ImportedMacroNotFound {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_macro_extern_deprecated)]
+#[diag("`#[macro_escape]` is a deprecated synonym for `#[macro_use]`")]
 pub(crate) struct MacroExternDeprecated {
     #[primary_span]
     pub(crate) span: Span,
-    #[help]
+    #[help("try an outer attribute: `#[macro_use]`")]
     pub inner_attribute: bool,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_arguments_macro_use_not_allowed)]
+#[diag("arguments to `macro_use` are not allowed here")]
 pub(crate) struct ArgumentsMacroUseNotAllowed {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_unnamed_crate_root_import)]
+#[diag("crate root imports need to be explicitly named: `use crate as name;`")]
 pub(crate) struct UnnamedCrateRootImport {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_macro_expanded_extern_crate_cannot_shadow_extern_arguments)]
+#[diag("macro-expanded `extern crate` items cannot shadow names passed with `--extern`")]
 pub(crate) struct MacroExpandedExternCrateCannotShadowExternArguments {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_elided_anonymous_lifetime_report_error, code = E0637)]
+#[diag("`&` without an explicit lifetime name cannot be used here", code = E0637)]
 pub(crate) struct ElidedAnonymousLifetimeReportError {
     #[primary_span]
-    #[label]
+    #[label("explicit lifetime name needed here")]
     pub(crate) span: Span,
     #[subdiagnostic]
     pub(crate) suggestion: Option<ElidedAnonymousLifetimeReportErrorSuggestion>,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_lending_iterator_report_error)]
+#[diag(
+    "associated type `Iterator::Item` is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type"
+)]
 pub(crate) struct LendingIteratorReportError {
     #[primary_span]
     pub(crate) lifetime: Span,
-    #[note]
+    #[note(
+        "you can't create an `Iterator` that borrows each `Item` from itself, but you can instead create a new type that borrows your existing type and implement `Iterator` for that new type"
+    )]
     pub(crate) ty: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_anonymous_lifetime_non_gat_report_error)]
+#[diag("missing lifetime in associated type")]
 pub(crate) struct AnonymousLifetimeNonGatReportError {
     #[primary_span]
-    #[label]
+    #[label("this lifetime must come from the implemented type")]
     pub(crate) lifetime: Span,
-    #[note]
+    #[note(
+        "in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type"
+    )]
     pub(crate) decl: MultiSpan,
 }
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    resolve_elided_anonymous_lifetime_report_error_suggestion,
+    "consider introducing a higher-ranked lifetime here",
     applicability = "machine-applicable"
 )]
 pub(crate) struct ElidedAnonymousLifetimeReportErrorSuggestion {
@@ -997,15 +1039,15 @@ pub(crate) struct ElidedAnonymousLifetimeReportErrorSuggestion {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_explicit_anonymous_lifetime_report_error, code = E0637)]
+#[diag("`'_` cannot be used here", code = E0637)]
 pub(crate) struct ExplicitAnonymousLifetimeReportError {
     #[primary_span]
-    #[label]
+    #[label("`'_` is a reserved lifetime name")]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_implicit_elided_lifetimes_not_allowed_here, code = E0726)]
+#[diag("implicit elided lifetime not allowed here", code = E0726)]
 pub(crate) struct ImplicitElidedLifetimeNotAllowedHere {
     #[primary_span]
     pub(crate) span: Span,
@@ -1014,25 +1056,25 @@ pub(crate) struct ImplicitElidedLifetimeNotAllowedHere {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_underscore_lifetime_is_reserved, code = E0637)]
-#[help]
+#[diag("`'_` cannot be used here", code = E0637)]
+#[help("use another lifetime specifier")]
 pub(crate) struct UnderscoreLifetimeIsReserved {
     #[primary_span]
-    #[label]
+    #[label("`'_` is a reserved lifetime name")]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_static_lifetime_is_reserved, code = E0262)]
+#[diag("invalid lifetime parameter name: `{$lifetime}`", code = E0262)]
 pub(crate) struct StaticLifetimeIsReserved {
     #[primary_span]
-    #[label]
+    #[label("'static is a reserved lifetime name")]
     pub(crate) span: Span,
     pub(crate) lifetime: Ident,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_variable_is_not_bound_in_all_patterns, code = E0408)]
+#[diag("variable `{$name}` is not bound in all patterns", code = E0408)]
 pub(crate) struct VariableIsNotBoundInAllPatterns {
     #[primary_span]
     pub(crate) multispan: MultiSpan,
@@ -1040,7 +1082,7 @@ pub(crate) struct VariableIsNotBoundInAllPatterns {
 }
 
 #[derive(Subdiagnostic, Debug, Clone)]
-#[label(resolve_pattern_doesnt_bind_name)]
+#[label("pattern doesn't bind `{$name}`")]
 pub(crate) struct PatternDoesntBindName {
     #[primary_span]
     pub(crate) span: Span,
@@ -1048,7 +1090,7 @@ pub(crate) struct PatternDoesntBindName {
 }
 
 #[derive(Subdiagnostic, Debug, Clone)]
-#[label(resolve_variable_not_in_all_patterns)]
+#[label("variable not in all patterns")]
 pub(crate) struct VariableNotInAllPatterns {
     #[primary_span]
     pub(crate) span: Span,
@@ -1056,7 +1098,7 @@ pub(crate) struct VariableNotInAllPatterns {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    resolve_variable_is_a_typo,
+    "you might have meant to use the similarly named previously used binding `{$typo}`",
     applicability = "maybe-incorrect",
     style = "verbose"
 )]
@@ -1067,8 +1109,8 @@ pub(crate) struct PatternBindingTypo {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_name_defined_multiple_time)]
-#[note]
+#[diag("the name `{$name}` is defined multiple times")]
+#[note("`{$name}` must be defined only once in the {$descr} namespace of this {$container}")]
 pub(crate) struct NameDefinedMultipleTime {
     #[primary_span]
     pub(crate) span: Span,
@@ -1083,12 +1125,12 @@ pub(crate) struct NameDefinedMultipleTime {
 
 #[derive(Subdiagnostic)]
 pub(crate) enum NameDefinedMultipleTimeLabel {
-    #[label(resolve_name_defined_multiple_time_reimported)]
+    #[label("`{$name}` reimported here")]
     Reimported {
         #[primary_span]
         span: Span,
     },
-    #[label(resolve_name_defined_multiple_time_redefined)]
+    #[label("`{$name}` redefined here")]
     Redefined {
         #[primary_span]
         span: Span,
@@ -1097,13 +1139,13 @@ pub(crate) enum NameDefinedMultipleTimeLabel {
 
 #[derive(Subdiagnostic)]
 pub(crate) enum NameDefinedMultipleTimeOldBindingLabel {
-    #[label(resolve_name_defined_multiple_time_old_binding_import)]
+    #[label("previous import of the {$old_kind} `{$name}` here")]
     Import {
         #[primary_span]
         span: Span,
         old_kind: &'static str,
     },
-    #[label(resolve_name_defined_multiple_time_old_binding_definition)]
+    #[label("previous definition of the {$old_kind} `{$name}` here")]
     Definition {
         #[primary_span]
         span: Span,
@@ -1112,42 +1154,42 @@ pub(crate) enum NameDefinedMultipleTimeOldBindingLabel {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_is_private, code = E0603)]
+#[diag("{$ident_descr} `{$ident}` is private", code = E0603)]
 pub(crate) struct IsPrivate<'a> {
     #[primary_span]
-    #[label]
+    #[label("private {$ident_descr}")]
     pub(crate) span: Span,
     pub(crate) ident_descr: &'a str,
     pub(crate) ident: Ident,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_generic_arguments_in_macro_path)]
+#[diag("generic arguments in macro path")]
 pub(crate) struct GenericArgumentsInMacroPath {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_attributes_starting_with_rustc_are_reserved)]
+#[diag("attributes starting with `rustc` are reserved for use by the `rustc` compiler")]
 pub(crate) struct AttributesStartingWithRustcAreReserved {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_use_through_an_import)]
+#[diag("cannot use {$article} {$descr} through an import")]
 pub(crate) struct CannotUseThroughAnImport {
     #[primary_span]
     pub(crate) span: Span,
     pub(crate) article: &'static str,
     pub(crate) descr: &'static str,
-    #[note]
+    #[note("the {$descr} imported here")]
     pub(crate) binding_span: Option<Span>,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_name_reserved_in_attribute_namespace)]
+#[diag("name `{$ident}` is reserved in attribute namespace")]
 pub(crate) struct NameReservedInAttributeNamespace {
     #[primary_span]
     pub(crate) span: Span,
@@ -1155,7 +1197,7 @@ pub(crate) struct NameReservedInAttributeNamespace {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_cannot_find_builtin_macro_with_name)]
+#[diag("cannot find a built-in macro with name `{$ident}`")]
 pub(crate) struct CannotFindBuiltinMacroWithName {
     #[primary_span]
     pub(crate) span: Span,
@@ -1163,34 +1205,34 @@ pub(crate) struct CannotFindBuiltinMacroWithName {
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_tool_was_already_registered)]
+#[diag("tool `{$tool}` was already registered")]
 pub(crate) struct ToolWasAlreadyRegistered {
     #[primary_span]
     pub(crate) span: Span,
     pub(crate) tool: Ident,
-    #[label]
+    #[label("already registered here")]
     pub(crate) old_ident_span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_tool_only_accepts_identifiers)]
+#[diag("`{$tool}` only accepts identifiers")]
 pub(crate) struct ToolOnlyAcceptsIdentifiers {
     #[primary_span]
-    #[label]
+    #[label("not an identifier")]
     pub(crate) span: Span,
     pub(crate) tool: Symbol,
 }
 
 #[derive(Subdiagnostic)]
 pub(crate) enum DefinedHere {
-    #[label(resolve_similarly_named_defined_here)]
+    #[label("similarly named {$candidate_descr} `{$candidate}` defined here")]
     SimilarlyNamed {
         #[primary_span]
         span: Span,
         candidate_descr: &'static str,
         candidate: Symbol,
     },
-    #[label(resolve_single_item_defined_here)]
+    #[label("{$candidate_descr} `{$candidate}` defined here")]
     SingleItem {
         #[primary_span]
         span: Span,
@@ -1200,7 +1242,7 @@ pub(crate) enum DefinedHere {
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_outer_ident_is_not_publicly_reexported)]
+#[label("{$outer_ident_descr} `{$outer_ident}` is not publicly re-exported")]
 pub(crate) struct OuterIdentIsNotPubliclyReexported {
     #[primary_span]
     pub(crate) span: Span,
@@ -1209,7 +1251,7 @@ pub(crate) struct OuterIdentIsNotPubliclyReexported {
 }
 
 #[derive(Subdiagnostic)]
-#[label(resolve_constructor_private_if_any_field_private)]
+#[label("a constructor is private if any of the fields is private")]
 pub(crate) struct ConstructorPrivateIfAnyFieldPrivate {
     #[primary_span]
     pub(crate) span: Span,
@@ -1217,7 +1259,10 @@ pub(crate) struct ConstructorPrivateIfAnyFieldPrivate {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    resolve_consider_making_the_field_public,
+    "{ $number_of_fields ->
+        [one] consider making the field publicly accessible
+        *[other] consider making the fields publicly accessible
+    }",
     applicability = "maybe-incorrect",
     style = "verbose"
 )]
@@ -1230,7 +1275,7 @@ pub(crate) struct ConsiderMakingTheFieldPublic {
 #[derive(Subdiagnostic)]
 pub(crate) enum ImportIdent {
     #[suggestion(
-        resolve_suggestion_import_ident_through_reexport,
+        "import `{$ident}` through the re-export",
         code = "{path}",
         applicability = "machine-applicable",
         style = "verbose"
@@ -1242,7 +1287,7 @@ pub(crate) enum ImportIdent {
         path: String,
     },
     #[suggestion(
-        resolve_suggestion_import_ident_directly,
+        "import `{$ident}` directly",
         code = "{path}",
         applicability = "machine-applicable",
         style = "verbose"
@@ -1256,7 +1301,18 @@ pub(crate) enum ImportIdent {
 }
 
 #[derive(Subdiagnostic)]
-#[note(resolve_note_and_refers_to_the_item_defined_here)]
+#[note(
+    "{$first ->
+        [true] {$dots ->
+            [true] the {$binding_descr} `{$binding_name}` is defined here...
+            *[false] the {$binding_descr} `{$binding_name}` is defined here
+        }
+        *[false] {$dots ->
+            [true] ...and refers to the {$binding_descr} `{$binding_name}` which is defined here...
+            *[false] ...and refers to the {$binding_descr} `{$binding_name}` which is defined here
+        }
+    }"
+)]
 pub(crate) struct NoteAndRefersToTheItemDefinedHere<'a> {
     #[primary_span]
     pub(crate) span: MultiSpan,
@@ -1267,7 +1323,7 @@ pub(crate) struct NoteAndRefersToTheItemDefinedHere<'a> {
 }
 
 #[derive(Subdiagnostic)]
-#[suggestion(resolve_remove_unnecessary_import, code = "", applicability = "maybe-incorrect")]
+#[suggestion("remove unnecessary import", code = "", applicability = "maybe-incorrect")]
 pub(crate) struct RemoveUnnecessaryImport {
     #[primary_span]
     pub(crate) span: Span,
@@ -1275,7 +1331,7 @@ pub(crate) struct RemoveUnnecessaryImport {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_remove_unnecessary_import,
+    "remove unnecessary import",
     code = "",
     applicability = "maybe-incorrect",
     style = "tool-only"
@@ -1286,7 +1342,7 @@ pub(crate) struct ToolOnlyRemoveUnnecessaryImport {
 }
 
 #[derive(Subdiagnostic)]
-#[note(resolve_ident_imported_here_but_it_is_desc)]
+#[note("`{$imported_ident}` is imported here, but it is {$imported_ident_desc}")]
 pub(crate) struct IdentImporterHereButItIsDesc<'a> {
     #[primary_span]
     pub(crate) span: Span,
@@ -1295,7 +1351,7 @@ pub(crate) struct IdentImporterHereButItIsDesc<'a> {
 }
 
 #[derive(Subdiagnostic)]
-#[note(resolve_ident_in_scope_but_it_is_desc)]
+#[note("`{$imported_ident}` is in scope, but it is {$imported_ident_desc}")]
 pub(crate) struct IdentInScopeButItIsDesc<'a> {
     pub(crate) imported_ident: Ident,
     pub(crate) imported_ident_desc: &'a str,
@@ -1319,50 +1375,55 @@ impl Subdiagnostic for FoundItemConfigureOut {
                 let key = "feature".into();
                 let value = feature.into_diag_arg(&mut None);
                 let msg = diag.dcx.eagerly_translate_to_string(
-                    fluent::resolve_item_was_behind_feature,
+                    inline_fluent!("the item is gated behind the `{$feature}` feature"),
                     [(&key, &value)].into_iter(),
                 );
                 multispan.push_span_label(span, msg);
             }
             ItemWas::CfgOut { span } => {
-                multispan.push_span_label(span, fluent::resolve_item_was_cfg_out);
+                multispan.push_span_label(span, inline_fluent!("the item is gated here"));
             }
         }
-        diag.span_note(multispan, fluent::resolve_found_an_item_configured_out);
+        diag.span_note(multispan, inline_fluent!("found an item that was configured out"));
     }
 }
 
 #[derive(Diagnostic)]
-#[diag(resolve_trait_impl_mismatch)]
+#[diag("item `{$name}` is an associated {$kind}, which doesn't match its trait `{$trait_path}`")]
 pub(crate) struct TraitImplMismatch {
     #[primary_span]
-    #[label]
+    #[label("does not match trait")]
     pub(crate) span: Span,
     pub(crate) name: Ident,
     pub(crate) kind: &'static str,
     pub(crate) trait_path: String,
-    #[label(resolve_trait_impl_mismatch_label_item)]
+    #[label("item in trait")]
     pub(crate) trait_item_span: Span,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_legacy_derive_helpers)]
+#[diag("derive helper attribute is used before it is introduced")]
 pub(crate) struct LegacyDeriveHelpers {
-    #[label]
+    #[label("the attribute is introduced here")]
     pub span: Span,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_unused_extern_crate)]
+#[diag("unused extern crate")]
 pub(crate) struct UnusedExternCrate {
-    #[label]
+    #[label("unused")]
     pub span: Span,
-    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
+    #[suggestion(
+        "remove the unused `extern crate`",
+        code = "",
+        applicability = "machine-applicable",
+        style = "verbose"
+    )]
     pub removal_span: Span,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_reexport_private_dependency)]
+#[diag("{$kind} `{$name}` from private dependency '{$krate}' is re-exported")]
 pub(crate) struct ReexportPrivateDependency {
     pub name: Symbol,
     pub kind: &'static str,
@@ -1370,32 +1431,32 @@ pub(crate) struct ReexportPrivateDependency {
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_unused_label)]
+#[diag("unused label")]
 pub(crate) struct UnusedLabel;
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_unused_macro_use)]
+#[diag("unused `#[macro_use]` import")]
 pub(crate) struct UnusedMacroUse;
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_macro_use_deprecated)]
-#[help]
+#[diag("applying the `#[macro_use]` attribute to an `extern crate` item is deprecated")]
+#[help("remove it and import macros at use sites with a `use` item instead")]
 pub(crate) struct MacroUseDeprecated;
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_macro_is_private)]
+#[diag("macro `{$ident}` is private")]
 pub(crate) struct MacroIsPrivate {
     pub ident: Ident,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_unused_macro_definition)]
+#[diag("unused macro definition: `{$name}`")]
 pub(crate) struct UnusedMacroDefinition {
     pub name: Symbol,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_macro_rule_never_used)]
+#[diag("rule #{$n} of macro `{$name}` is never used")]
 pub(crate) struct MacroRuleNeverUsed {
     pub n: usize,
     pub name: Symbol,
@@ -1412,36 +1473,43 @@ impl<'a> LintDiagnostic<'a, ()> for UnstableFeature {
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_extern_crate_not_idiomatic)]
+#[diag("`extern crate` is not idiomatic in the new edition")]
 pub(crate) struct ExternCrateNotIdiomatic {
-    #[suggestion(style = "verbose", code = "{code}", applicability = "machine-applicable")]
+    #[suggestion(
+        "convert it to a `use`",
+        style = "verbose",
+        code = "{code}",
+        applicability = "machine-applicable"
+    )]
     pub span: Span,
     pub code: &'static str,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_out_of_scope_macro_calls)]
-#[help]
+#[diag("cannot find macro `{$path}` in the current scope when looking from {$location}")]
+#[help("import `macro_rules` with `use` to make it callable above its definition")]
 pub(crate) struct OutOfScopeMacroCalls {
-    #[label]
+    #[label("not found from {$location}")]
     pub span: Span,
     pub path: String,
     pub location: String,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_redundant_import_visibility)]
+#[diag(
+    "glob import doesn't reexport anything with visibility `{$import_vis}` because no imported item is public enough"
+)]
 pub(crate) struct RedundantImportVisibility {
-    #[note]
+    #[note("the most public imported item is `{$max_vis}`")]
     pub span: Span,
-    #[help]
+    #[help("reduce the glob import's visibility or increase visibility of imported items")]
     pub help: (),
     pub import_vis: String,
     pub max_vis: String,
 }
 
 #[derive(LintDiagnostic)]
-#[diag(resolve_unknown_diagnostic_attribute)]
+#[diag("unknown diagnostic attribute")]
 pub(crate) struct UnknownDiagnosticAttribute {
     #[subdiagnostic]
     pub typo: Option<UnknownDiagnosticAttributeTypoSugg>,
@@ -1449,7 +1517,7 @@ pub(crate) struct UnknownDiagnosticAttribute {
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    resolve_unknown_diagnostic_attribute_typo_sugg,
+    "an attribute with a similar name exists",
     style = "verbose",
     code = "{typo_name}",
     applicability = "machine-applicable"
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 659b74b74df77..36ec173cc571f 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -98,8 +98,6 @@ pub use macros::registered_tools_ast;
 
 use crate::ref_mut::{CmCell, CmRefCell};
 
-rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
-
 #[derive(Copy, Clone, PartialEq, Debug)]
 enum Determinacy {
     Determined,