diff --git a/Cargo.lock b/Cargo.lock
index 1631d5362612e..e9cdc493451d6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3490,7 +3490,6 @@ dependencies = [
  "rustc_data_structures",
  "rustc_errors",
  "rustc_feature",
- "rustc_fluent_macro",
  "rustc_hir",
  "rustc_index",
  "rustc_macros",
@@ -3775,7 +3774,6 @@ dependencies = [
  "libc",
  "rustc_abi",
  "rustc_ast",
- "rustc_ast_lowering",
  "rustc_ast_passes",
  "rustc_ast_pretty",
  "rustc_borrowck",
diff --git a/compiler/rustc_ast_lowering/Cargo.toml b/compiler/rustc_ast_lowering/Cargo.toml
index 6ac258155fe94..c00bac5d3c5a5 100644
--- a/compiler/rustc_ast_lowering/Cargo.toml
+++ b/compiler/rustc_ast_lowering/Cargo.toml
@@ -15,7 +15,6 @@ rustc_attr_parsing = { path = "../rustc_attr_parsing" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 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_ast_lowering/messages.ftl b/compiler/rustc_ast_lowering/messages.ftl
deleted file mode 100644
index 0cd5c4f303dee..0000000000000
--- a/compiler/rustc_ast_lowering/messages.ftl
+++ /dev/null
@@ -1,191 +0,0 @@
-ast_lowering_abi_specified_multiple_times =
-    `{$prev_name}` ABI specified multiple times
-    .label = previously specified here
-    .note = these ABIs are equivalent on the current target
-
-ast_lowering_arbitrary_expression_in_pattern =
-    arbitrary expressions aren't allowed in patterns
-    .pattern_from_macro_note = the `expr` fragment specifier forces the metavariable's content to be an expression
-    .const_block_in_pattern_help = use a named `const`-item or an `if`-guard (`x if x == const {"{ ... }"}`) instead
-
-ast_lowering_argument = argument
-
-ast_lowering_assoc_ty_binding_in_dyn =
-    associated type bounds are not allowed in `dyn` types
-    .suggestion = use `impl Trait` to introduce a type instead
-
-ast_lowering_assoc_ty_parentheses =
-    parenthesized generic arguments cannot be used in associated type constraints
-
-ast_lowering_async_bound_not_on_trait =
-    `async` bound modifier only allowed on trait, not `{$descr}`
-
-ast_lowering_async_bound_only_for_fn_traits =
-    `async` bound modifier only allowed on `Fn`/`FnMut`/`FnOnce` traits
-
-ast_lowering_async_coroutines_not_supported =
-    `async` coroutines are not yet supported
-
-ast_lowering_att_syntax_only_x86 =
-    the `att_syntax` option is only supported on x86
-
-ast_lowering_await_only_in_async_fn_and_blocks =
-    `await` is only allowed inside `async` functions and blocks
-    .label = only allowed inside `async` functions and blocks
-
-ast_lowering_bad_return_type_notation_inputs =
-    argument types not allowed with return type notation
-    .suggestion = remove the input types
-
-ast_lowering_bad_return_type_notation_needs_dots = return type notation arguments must be elided with `..`
-    .suggestion = use the correct syntax by adding `..` to the arguments
-
-ast_lowering_bad_return_type_notation_output =
-    return type not allowed with return type notation
-ast_lowering_bad_return_type_notation_output_suggestion = use the right argument notation and remove the return type
-
-ast_lowering_bad_return_type_notation_position = return type notation not allowed in this position yet
-
-ast_lowering_clobber_abi_not_supported =
-    `clobber_abi` is not supported on this target
-
-ast_lowering_closure_cannot_be_static = closures cannot be static
-
-ast_lowering_coroutine_too_many_parameters =
-    too many parameters for a coroutine (expected 0 or 1 parameters)
-
-ast_lowering_default_field_in_tuple = default fields are not supported in tuple structs
-    .label = default fields are only supported on structs
-
-ast_lowering_delegation_cycle_in_signature_resolution = encountered a cycle during delegation signature resolution
-ast_lowering_delegation_unresolved_callee = failed to resolve delegation callee
-ast_lowering_does_not_support_modifiers =
-    the `{$class_name}` register class does not support template modifiers
-
-ast_lowering_extra_double_dot =
-    `..` can only be used once per {$ctx} pattern
-    .label = can only be used once per {$ctx} pattern
-
-ast_lowering_functional_record_update_destructuring_assignment =
-    functional record updates are not allowed in destructuring assignments
-    .suggestion = consider removing the trailing pattern
-
-ast_lowering_generic_param_default_in_binder =
-    defaults for generic parameters are not allowed in `for<...>` binders
-
-ast_lowering_generic_type_with_parentheses =
-    parenthesized type parameters may only be used with a `Fn` trait
-    .label = only `Fn` traits may use parentheses
-
-ast_lowering_inclusive_range_with_no_end = inclusive range with no end
-
-ast_lowering_inline_asm_unsupported_target =
-    inline assembly is unsupported on this target
-
-ast_lowering_invalid_abi =
-    invalid ABI: found `{$abi}`
-    .label = invalid ABI
-    .note = invoke `{$command}` for a full list of supported calling conventions
-
-ast_lowering_invalid_abi_clobber_abi =
-    invalid ABI for `clobber_abi`
-    .note = the following ABIs are supported on this target: {$supported_abis}
-
-ast_lowering_invalid_abi_suggestion = there's a similarly named valid ABI `{$suggestion}`
-
-ast_lowering_invalid_asm_template_modifier_const =
-    asm template modifiers are not allowed for `const` arguments
-
-ast_lowering_invalid_asm_template_modifier_label =
-    asm template modifiers are not allowed for `label` arguments
-
-ast_lowering_invalid_asm_template_modifier_reg_class =
-    invalid asm template modifier for this register class
-
-ast_lowering_invalid_asm_template_modifier_sym =
-    asm template modifiers are not allowed for `sym` arguments
-
-ast_lowering_invalid_legacy_const_generic_arg =
-    invalid argument to a legacy const generic: cannot have const blocks, closures, async blocks or items
-
-ast_lowering_invalid_legacy_const_generic_arg_suggestion =
-    try using a const generic argument instead
-
-ast_lowering_invalid_register =
-    invalid register `{$reg}`: {$error}
-
-ast_lowering_invalid_register_class =
-    invalid register class `{$reg_class}`: unknown register class
-    .note = the following register classes are supported on this target: {$supported_register_classes}
-
-ast_lowering_match_arm_with_no_body =
-    `match` arm with no body
-    .suggestion = add a body after the pattern
-
-ast_lowering_misplaced_double_dot =
-    `..` patterns are not allowed here
-    .note = only allowed in tuple, tuple struct, and slice patterns
-
-ast_lowering_misplaced_impl_trait =
-    `impl Trait` is not allowed in {$position}
-    .note = `impl Trait` is only allowed in arguments and return types of functions and methods
-
-ast_lowering_never_pattern_with_body =
-    a never pattern is always unreachable
-    .label = this will never be executed
-    .suggestion = remove this expression
-
-ast_lowering_never_pattern_with_guard =
-    a guard on a never pattern will never be run
-    .suggestion = remove this guard
-
-ast_lowering_no_precise_captures_on_apit = `use<...>` precise capturing syntax not allowed in argument-position `impl Trait`
-
-ast_lowering_previously_used_here = previously used here
-
-ast_lowering_register1 = register `{$reg1_name}`
-
-ast_lowering_register2 = register `{$reg2_name}`
-
-ast_lowering_register_class_only_clobber =
-    register class `{$reg_class_name}` can only be used as a clobber, not as an input or output
-ast_lowering_register_class_only_clobber_stable =
-    register class `{$reg_class_name}` can only be used as a clobber in stable
-
-ast_lowering_register_conflict =
-    register `{$reg1_name}` conflicts with register `{$reg2_name}`
-    .help = use `lateout` instead of `out` to avoid conflict
-
-ast_lowering_remove_parentheses = remove these parentheses
-
-ast_lowering_sub_tuple_binding =
-    `{$ident_name} @` is not allowed in a {$ctx}
-    .label = this is only allowed in slice patterns
-    .help = remove this and bind each tuple field independently
-
-ast_lowering_sub_tuple_binding_suggestion = if you don't need to use the contents of {$ident}, discard the tuple's remaining fields
-
-ast_lowering_support_modifiers =
-    the `{$class_name}` register class supports the following template modifiers: {$modifiers}
-
-ast_lowering_template_modifier = template modifier
-
-ast_lowering_this_not_async = this is not `async`
-
-ast_lowering_underscore_expr_lhs_assign =
-    in expressions, `_` can only be used on the left-hand side of an assignment
-    .label = `_` not allowed here
-
-ast_lowering_union_default_field_values = unions cannot have default field values
-
-ast_lowering_unstable_inline_assembly = inline assembly is not stable yet on this architecture
-ast_lowering_unstable_inline_assembly_label_operand_with_outputs =
-    using both label and output operands for inline assembly is unstable
-ast_lowering_unstable_may_unwind = the `may_unwind` option is unstable
-
-ast_lowering_use_angle_brackets = use angle brackets instead
-
-ast_lowering_yield = yield syntax is experimental
-ast_lowering_yield_in_closure =
-    `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
-    .suggestion = use `#[coroutine]` to make this closure a coroutine
diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index 36fcd4b924c88..fc1f198e8b2ab 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -3,6 +3,7 @@ use std::fmt::Write;
 
 use rustc_ast::*;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
+use rustc_errors::inline_fluent;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_session::parse::feature_err;
@@ -19,8 +20,7 @@ use super::errors::{
     RegisterConflict,
 };
 use crate::{
-    AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, ParamMode,
-    ResolverAstLoweringExt, fluent_generated as fluent,
+    AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, ParamMode, ResolverAstLoweringExt,
 };
 
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
@@ -67,7 +67,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     &self.tcx.sess,
                     sym::asm_experimental_arch,
                     sp,
-                    fluent::ast_lowering_unstable_inline_assembly,
+                    inline_fluent!("inline assembly is not stable yet on this architecture"),
                 )
                 .emit();
             }
@@ -84,7 +84,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 &self.tcx.sess,
                 sym::asm_unwind,
                 sp,
-                fluent::ast_lowering_unstable_may_unwind,
+                inline_fluent!("the `may_unwind` option is unstable"),
             )
             .emit();
         }
@@ -499,7 +499,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     sess,
                     sym::asm_goto_with_outputs,
                     *op_sp,
-                    fluent::ast_lowering_unstable_inline_assembly_label_operand_with_outputs,
+                    inline_fluent!(
+                        "using both label and output operands for inline assembly is unstable"
+                    ),
                 )
                 .emit();
             }
diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs
index 88e69e67d8a55..1eb72727df667 100644
--- a/compiler/rustc_ast_lowering/src/errors.rs
+++ b/compiler/rustc_ast_lowering/src/errors.rs
@@ -4,17 +4,17 @@ use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_generic_type_with_parentheses, code = E0214)]
+#[diag("parenthesized type parameters may only be used with a `Fn` trait", code = E0214)]
 pub(crate) struct GenericTypeWithParentheses {
     #[primary_span]
-    #[label]
+    #[label("only `Fn` traits may use parentheses")]
     pub span: Span,
     #[subdiagnostic]
     pub sub: Option<UseAngleBrackets>,
 }
 
 #[derive(Subdiagnostic)]
-#[multipart_suggestion(ast_lowering_use_angle_brackets, applicability = "maybe-incorrect")]
+#[multipart_suggestion("use angle brackets instead", applicability = "maybe-incorrect")]
 pub(crate) struct UseAngleBrackets {
     #[suggestion_part(code = "<")]
     pub open_param: Span,
@@ -23,11 +23,11 @@ pub(crate) struct UseAngleBrackets {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_invalid_abi, code = E0703)]
-#[note]
+#[diag("invalid ABI: found `{$abi}`", code = E0703)]
+#[note("invoke `{$command}` for a full list of supported calling conventions")]
 pub(crate) struct InvalidAbi {
     #[primary_span]
-    #[label]
+    #[label("invalid ABI")]
     pub span: Span,
     pub abi: Symbol,
     pub command: String,
@@ -36,16 +36,16 @@ pub(crate) struct InvalidAbi {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_default_field_in_tuple)]
+#[diag("default fields are not supported in tuple structs")]
 pub(crate) struct TupleStructWithDefault {
     #[primary_span]
-    #[label]
+    #[label("default fields are only supported on structs")]
     pub span: Span,
 }
 
 #[derive(Subdiagnostic)]
 #[suggestion(
-    ast_lowering_invalid_abi_suggestion,
+    "there's a similarly named valid ABI `{$suggestion}`",
     code = "\"{suggestion}\"",
     applicability = "maybe-incorrect",
     style = "verbose"
@@ -57,7 +57,7 @@ pub(crate) struct InvalidAbiSuggestion {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_assoc_ty_parentheses)]
+#[diag("parenthesized generic arguments cannot be used in associated type constraints")]
 pub(crate) struct AssocTyParentheses {
     #[primary_span]
     pub span: Span,
@@ -67,12 +67,12 @@ pub(crate) struct AssocTyParentheses {
 
 #[derive(Subdiagnostic)]
 pub(crate) enum AssocTyParenthesesSub {
-    #[multipart_suggestion(ast_lowering_remove_parentheses)]
+    #[multipart_suggestion("remove these parentheses")]
     Empty {
         #[suggestion_part(code = "")]
         parentheses_span: Span,
     },
-    #[multipart_suggestion(ast_lowering_use_angle_brackets)]
+    #[multipart_suggestion("use angle brackets instead")]
     NotEmpty {
         #[suggestion_part(code = "<")]
         open_param: Span,
@@ -82,8 +82,8 @@ pub(crate) enum AssocTyParenthesesSub {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_misplaced_impl_trait, code = E0562)]
-#[note]
+#[diag("`impl Trait` is not allowed in {$position}", code = E0562)]
+#[note("`impl Trait` is only allowed in arguments and return types of functions and methods")]
 pub(crate) struct MisplacedImplTrait<'a> {
     #[primary_span]
     pub span: Span,
@@ -91,97 +91,106 @@ pub(crate) struct MisplacedImplTrait<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_assoc_ty_binding_in_dyn)]
+#[diag("associated type bounds are not allowed in `dyn` types")]
 pub(crate) struct MisplacedAssocTyBinding {
     #[primary_span]
     pub span: Span,
-    #[suggestion(code = " = impl", applicability = "maybe-incorrect", style = "verbose")]
+    #[suggestion(
+        "use `impl Trait` to introduce a type instead",
+        code = " = impl",
+        applicability = "maybe-incorrect",
+        style = "verbose"
+    )]
     pub suggestion: Option<Span>,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_underscore_expr_lhs_assign)]
+#[diag("in expressions, `_` can only be used on the left-hand side of an assignment")]
 pub(crate) struct UnderscoreExprLhsAssign {
     #[primary_span]
-    #[label]
+    #[label("`_` not allowed here")]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_await_only_in_async_fn_and_blocks, code = E0728)]
+#[diag("`await` is only allowed inside `async` functions and blocks", code = E0728)]
 pub(crate) struct AwaitOnlyInAsyncFnAndBlocks {
     #[primary_span]
-    #[label]
+    #[label("only allowed inside `async` functions and blocks")]
     pub await_kw_span: Span,
-    #[label(ast_lowering_this_not_async)]
+    #[label("this is not `async`")]
     pub item_span: Option<Span>,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_coroutine_too_many_parameters, code = E0628)]
+#[diag("too many parameters for a coroutine (expected 0 or 1 parameters)", code = E0628)]
 pub(crate) struct CoroutineTooManyParameters {
     #[primary_span]
     pub fn_decl_span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_closure_cannot_be_static, code = E0697)]
+#[diag("closures cannot be static", code = E0697)]
 pub(crate) struct ClosureCannotBeStatic {
     #[primary_span]
     pub fn_decl_span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_functional_record_update_destructuring_assignment)]
+#[diag("functional record updates are not allowed in destructuring assignments")]
 pub(crate) struct FunctionalRecordUpdateDestructuringAssignment {
     #[primary_span]
-    #[suggestion(code = "", applicability = "machine-applicable")]
+    #[suggestion(
+        "consider removing the trailing pattern",
+        code = "",
+        applicability = "machine-applicable"
+    )]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_async_coroutines_not_supported, code = E0727)]
+#[diag("`async` coroutines are not yet supported", code = E0727)]
 pub(crate) struct AsyncCoroutinesNotSupported {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_inline_asm_unsupported_target, code = E0472)]
+#[diag("inline assembly is unsupported on this target", code = E0472)]
 pub(crate) struct InlineAsmUnsupportedTarget {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_att_syntax_only_x86)]
+#[diag("the `att_syntax` option is only supported on x86")]
 pub(crate) struct AttSyntaxOnlyX86 {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_abi_specified_multiple_times)]
+#[diag("`{$prev_name}` ABI specified multiple times")]
 pub(crate) struct AbiSpecifiedMultipleTimes {
     #[primary_span]
     pub abi_span: Span,
     pub prev_name: Symbol,
-    #[label]
+    #[label("previously specified here")]
     pub prev_span: Span,
-    #[note]
+    #[note("these ABIs are equivalent on the current target")]
     pub equivalent: bool,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_clobber_abi_not_supported)]
+#[diag("`clobber_abi` is not supported on this target")]
 pub(crate) struct ClobberAbiNotSupported {
     #[primary_span]
     pub abi_span: Span,
 }
 
 #[derive(Diagnostic)]
-#[note]
-#[diag(ast_lowering_invalid_abi_clobber_abi)]
+#[note("the following ABIs are supported on this target: {$supported_abis}")]
+#[diag("invalid ABI for `clobber_abi`")]
 pub(crate) struct InvalidAbiClobberAbi {
     #[primary_span]
     pub abi_span: Span,
@@ -189,7 +198,7 @@ pub(crate) struct InvalidAbiClobberAbi {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_invalid_register)]
+#[diag("invalid register `{$reg}`: {$error}")]
 pub(crate) struct InvalidRegister<'a> {
     #[primary_span]
     pub op_span: Span,
@@ -198,8 +207,10 @@ pub(crate) struct InvalidRegister<'a> {
 }
 
 #[derive(Diagnostic)]
-#[note]
-#[diag(ast_lowering_invalid_register_class)]
+#[note(
+    "the following register classes are supported on this target: {$supported_register_classes}"
+)]
+#[diag("invalid register class `{$reg_class}`: unknown register class")]
 pub(crate) struct InvalidRegisterClass {
     #[primary_span]
     pub op_span: Span,
@@ -208,12 +219,12 @@ pub(crate) struct InvalidRegisterClass {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_invalid_asm_template_modifier_reg_class)]
+#[diag("invalid asm template modifier for this register class")]
 pub(crate) struct InvalidAsmTemplateModifierRegClass {
     #[primary_span]
-    #[label(ast_lowering_template_modifier)]
+    #[label("template modifier")]
     pub placeholder_span: Span,
-    #[label(ast_lowering_argument)]
+    #[label("argument")]
     pub op_span: Span,
     #[subdiagnostic]
     pub sub: InvalidAsmTemplateModifierRegClassSub,
@@ -221,44 +232,48 @@ pub(crate) struct InvalidAsmTemplateModifierRegClass {
 
 #[derive(Subdiagnostic)]
 pub(crate) enum InvalidAsmTemplateModifierRegClassSub {
-    #[note(ast_lowering_support_modifiers)]
+    #[note(
+        "the `{$class_name}` register class supports the following template modifiers: {$modifiers}"
+    )]
     SupportModifier { class_name: Symbol, modifiers: String },
-    #[note(ast_lowering_does_not_support_modifiers)]
+    #[note("the `{$class_name}` register class does not support template modifiers")]
     DoesNotSupportModifier { class_name: Symbol },
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_invalid_asm_template_modifier_const)]
+#[diag("asm template modifiers are not allowed for `const` arguments")]
 pub(crate) struct InvalidAsmTemplateModifierConst {
     #[primary_span]
-    #[label(ast_lowering_template_modifier)]
+    #[label("template modifier")]
     pub placeholder_span: Span,
-    #[label(ast_lowering_argument)]
+    #[label("argument")]
     pub op_span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_invalid_asm_template_modifier_sym)]
+#[diag("asm template modifiers are not allowed for `sym` arguments")]
 pub(crate) struct InvalidAsmTemplateModifierSym {
     #[primary_span]
-    #[label(ast_lowering_template_modifier)]
+    #[label("template modifier")]
     pub placeholder_span: Span,
-    #[label(ast_lowering_argument)]
+    #[label("argument")]
     pub op_span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_invalid_asm_template_modifier_label)]
+#[diag("asm template modifiers are not allowed for `label` arguments")]
 pub(crate) struct InvalidAsmTemplateModifierLabel {
     #[primary_span]
-    #[label(ast_lowering_template_modifier)]
+    #[label("template modifier")]
     pub placeholder_span: Span,
-    #[label(ast_lowering_argument)]
+    #[label("argument")]
     pub op_span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_register_class_only_clobber)]
+#[diag(
+    "register class `{$reg_class_name}` can only be used as a clobber, not as an input or output"
+)]
 pub(crate) struct RegisterClassOnlyClobber {
     #[primary_span]
     pub op_span: Span,
@@ -266,7 +281,7 @@ pub(crate) struct RegisterClassOnlyClobber {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_register_class_only_clobber_stable)]
+#[diag("register class `{$reg_class_name}` can only be used as a clobber in stable")]
 pub(crate) struct RegisterClassOnlyClobberStable {
     #[primary_span]
     pub op_span: Span,
@@ -274,27 +289,27 @@ pub(crate) struct RegisterClassOnlyClobberStable {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_register_conflict)]
+#[diag("register `{$reg1_name}` conflicts with register `{$reg2_name}`")]
 pub(crate) struct RegisterConflict<'a> {
     #[primary_span]
-    #[label(ast_lowering_register1)]
+    #[label("register `{$reg1_name}`")]
     pub op_span1: Span,
-    #[label(ast_lowering_register2)]
+    #[label("register `{$reg2_name}`")]
     pub op_span2: Span,
     pub reg1_name: &'a str,
     pub reg2_name: &'a str,
-    #[help]
+    #[help("use `lateout` instead of `out` to avoid conflict")]
     pub in_out: Option<Span>,
 }
 
 #[derive(Diagnostic)]
-#[help]
-#[diag(ast_lowering_sub_tuple_binding)]
+#[help("remove this and bind each tuple field independently")]
+#[diag("`{$ident_name} @` is not allowed in a {$ctx}")]
 pub(crate) struct SubTupleBinding<'a> {
     #[primary_span]
-    #[label]
+    #[label("this is only allowed in slice patterns")]
     #[suggestion(
-        ast_lowering_sub_tuple_binding_suggestion,
+        "if you don't need to use the contents of {$ident}, discard the tuple's remaining fields",
         style = "verbose",
         code = "..",
         applicability = "maybe-incorrect"
@@ -306,63 +321,67 @@ pub(crate) struct SubTupleBinding<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_extra_double_dot)]
+#[diag("`..` can only be used once per {$ctx} pattern")]
 pub(crate) struct ExtraDoubleDot<'a> {
     #[primary_span]
-    #[label]
+    #[label("can only be used once per {$ctx} pattern")]
     pub span: Span,
-    #[label(ast_lowering_previously_used_here)]
+    #[label("previously used here")]
     pub prev_span: Span,
     pub ctx: &'a str,
 }
 
 #[derive(Diagnostic)]
-#[note]
-#[diag(ast_lowering_misplaced_double_dot)]
+#[note("only allowed in tuple, tuple struct, and slice patterns")]
+#[diag("`..` patterns are not allowed here")]
 pub(crate) struct MisplacedDoubleDot {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_match_arm_with_no_body)]
+#[diag("`match` arm with no body")]
 pub(crate) struct MatchArmWithNoBody {
     #[primary_span]
     pub span: Span,
-    #[suggestion(code = " => todo!(),", applicability = "has-placeholders")]
+    #[suggestion(
+        "add a body after the pattern",
+        code = " => todo!(),",
+        applicability = "has-placeholders"
+    )]
     pub suggestion: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_never_pattern_with_body)]
+#[diag("a never pattern is always unreachable")]
 pub(crate) struct NeverPatternWithBody {
     #[primary_span]
-    #[label]
-    #[suggestion(code = "", applicability = "maybe-incorrect")]
+    #[label("this will never be executed")]
+    #[suggestion("remove this expression", code = "", applicability = "maybe-incorrect")]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_never_pattern_with_guard)]
+#[diag("a guard on a never pattern will never be run")]
 pub(crate) struct NeverPatternWithGuard {
     #[primary_span]
-    #[suggestion(code = "", applicability = "maybe-incorrect")]
+    #[suggestion("remove this guard", code = "", applicability = "maybe-incorrect")]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_arbitrary_expression_in_pattern)]
+#[diag("arbitrary expressions aren't allowed in patterns")]
 pub(crate) struct ArbitraryExpressionInPattern {
     #[primary_span]
     pub span: Span,
-    #[note(ast_lowering_pattern_from_macro_note)]
+    #[note("the `expr` fragment specifier forces the metavariable's content to be an expression")]
     pub pattern_from_macro_note: bool,
-    #[help(ast_lowering_const_block_in_pattern_help)]
+    #[help("use a named `const`-item or an `if`-guard (`x if x == const {\"{ ... }\"}`) instead")]
     pub const_block_in_pattern_help: bool,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_inclusive_range_with_no_end)]
+#[diag("inclusive range with no end")]
 pub(crate) struct InclusiveRangeWithNoEnd {
     #[primary_span]
     pub span: Span,
@@ -370,7 +389,7 @@ pub(crate) struct InclusiveRangeWithNoEnd {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    ast_lowering_bad_return_type_notation_output_suggestion,
+    "use the right argument notation and remove the return type",
     applicability = "machine-applicable",
     style = "verbose"
 )]
@@ -384,26 +403,36 @@ pub(crate) struct RTNSuggestion {
 
 #[derive(Diagnostic)]
 pub(crate) enum BadReturnTypeNotation {
-    #[diag(ast_lowering_bad_return_type_notation_inputs)]
+    #[diag("argument types not allowed with return type notation")]
     Inputs {
         #[primary_span]
-        #[suggestion(code = "(..)", applicability = "machine-applicable", style = "verbose")]
+        #[suggestion(
+            "remove the input types",
+            code = "(..)",
+            applicability = "machine-applicable",
+            style = "verbose"
+        )]
         span: Span,
     },
-    #[diag(ast_lowering_bad_return_type_notation_output)]
+    #[diag("return type not allowed with return type notation")]
     Output {
         #[primary_span]
         span: Span,
         #[subdiagnostic]
         suggestion: RTNSuggestion,
     },
-    #[diag(ast_lowering_bad_return_type_notation_needs_dots)]
+    #[diag("return type notation arguments must be elided with `..`")]
     NeedsDots {
         #[primary_span]
-        #[suggestion(code = "(..)", applicability = "machine-applicable", style = "verbose")]
+        #[suggestion(
+            "use the correct syntax by adding `..` to the arguments",
+            code = "(..)",
+            applicability = "machine-applicable",
+            style = "verbose"
+        )]
         span: Span,
     },
-    #[diag(ast_lowering_bad_return_type_notation_position)]
+    #[diag("return type notation not allowed in this position yet")]
     Position {
         #[primary_span]
         span: Span,
@@ -411,14 +440,14 @@ pub(crate) enum BadReturnTypeNotation {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_generic_param_default_in_binder)]
+#[diag("defaults for generic parameters are not allowed in `for<...>` binders")]
 pub(crate) struct GenericParamDefaultInBinder {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_async_bound_not_on_trait)]
+#[diag("`async` bound modifier only allowed on trait, not `{$descr}`")]
 pub(crate) struct AsyncBoundNotOnTrait {
     #[primary_span]
     pub span: Span,
@@ -426,30 +455,37 @@ pub(crate) struct AsyncBoundNotOnTrait {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_async_bound_only_for_fn_traits)]
+#[diag("`async` bound modifier only allowed on `Fn`/`FnMut`/`FnOnce` traits")]
 pub(crate) struct AsyncBoundOnlyForFnTraits {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_no_precise_captures_on_apit)]
+#[diag("`use<...>` precise capturing syntax not allowed in argument-position `impl Trait`")]
 pub(crate) struct NoPreciseCapturesOnApit {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_yield_in_closure)]
+#[diag("`yield` can only be used in `#[coroutine]` closures, or `gen` blocks")]
 pub(crate) struct YieldInClosure {
     #[primary_span]
     pub span: Span,
-    #[suggestion(code = "#[coroutine] ", applicability = "maybe-incorrect", style = "verbose")]
+    #[suggestion(
+        "use `#[coroutine]` to make this closure a coroutine",
+        code = "#[coroutine] ",
+        applicability = "maybe-incorrect",
+        style = "verbose"
+    )]
     pub suggestion: Option<Span>,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_invalid_legacy_const_generic_arg)]
+#[diag(
+    "invalid argument to a legacy const generic: cannot have const blocks, closures, async blocks or items"
+)]
 pub(crate) struct InvalidLegacyConstGenericArg {
     #[primary_span]
     pub span: Span,
@@ -459,7 +495,7 @@ pub(crate) struct InvalidLegacyConstGenericArg {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(
-    ast_lowering_invalid_legacy_const_generic_arg_suggestion,
+    "try using a const generic argument instead",
     applicability = "maybe-incorrect"
 )]
 pub(crate) struct UseConstGenericArg {
@@ -472,21 +508,21 @@ pub(crate) struct UseConstGenericArg {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_union_default_field_values)]
+#[diag("unions cannot have default field values")]
 pub(crate) struct UnionWithDefault {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_delegation_unresolved_callee)]
+#[diag("failed to resolve delegation callee")]
 pub(crate) struct UnresolvedDelegationCallee {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_delegation_cycle_in_signature_resolution)]
+#[diag("encountered a cycle during delegation signature resolution")]
 pub(crate) struct CycleInDelegationSignatureResolution {
     #[primary_span]
     pub span: Span,
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 9fbfeb7a11e6e..051bebfbec00c 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -5,6 +5,7 @@ use std::sync::Arc;
 use rustc_ast::*;
 use rustc_ast_pretty::pprust::expr_to_string;
 use rustc_data_structures::stack::ensure_sufficient_stack;
+use rustc_errors::inline_fluent;
 use rustc_hir as hir;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, Res};
@@ -28,9 +29,7 @@ use super::{
     GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode, ResolverAstLoweringExt,
 };
 use crate::errors::{InvalidLegacyConstGenericArg, UseConstGenericArg, YieldInClosure};
-use crate::{
-    AllowReturnTypeNotation, FnDeclKind, ImplTraitPosition, TryBlockScope, fluent_generated,
-};
+use crate::{AllowReturnTypeNotation, FnDeclKind, ImplTraitPosition, TryBlockScope};
 
 struct WillCreateDefIdsVisitor {}
 
@@ -1703,7 +1702,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 &self.tcx.sess,
                 sym::yield_expr,
                 span,
-                fluent_generated::ast_lowering_yield,
+                inline_fluent!("yield syntax is experimental"),
             )
             .emit();
         }
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 8c6ee9d6bc630..e4f431fd2431c 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -88,8 +88,6 @@ mod pat;
 mod path;
 pub mod stability;
 
-rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
-
 struct LoweringContext<'a, 'hir> {
     tcx: TyCtxt<'hir>,
     resolver: &'a mut ResolverAstLowering,
diff --git a/compiler/rustc_driver_impl/Cargo.toml b/compiler/rustc_driver_impl/Cargo.toml
index d184b6c8947c6..f2b972da97894 100644
--- a/compiler/rustc_driver_impl/Cargo.toml
+++ b/compiler/rustc_driver_impl/Cargo.toml
@@ -9,7 +9,6 @@ anstyle = "1.0.13"
 jiff = { version = "0.2.5", default-features = false, features = ["std"] }
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
-rustc_ast_lowering = { path = "../rustc_ast_lowering" }
 rustc_ast_passes = { path = "../rustc_ast_passes" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_borrowck = { path = "../rustc_borrowck" }
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 3059a4fefc613..a37f0f92697b7 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -114,7 +114,6 @@ pub fn default_translator() -> Translator {
 
 pub static DEFAULT_LOCALE_RESOURCES: &[&str] = &[
     // tidy-alphabetical-start
-    rustc_ast_lowering::DEFAULT_LOCALE_RESOURCE,
     rustc_ast_passes::DEFAULT_LOCALE_RESOURCE,
     rustc_borrowck::DEFAULT_LOCALE_RESOURCE,
     rustc_builtin_macros::DEFAULT_LOCALE_RESOURCE,