From 5af55c3477242821dce6fa2917cc0b290f344f00 Mon Sep 17 00:00:00 2001
From: Boshen <boshenc@gmail.com>
Date: Sat, 11 May 2024 17:00:36 +0800
Subject: [PATCH] refactor(linter,diagnostic): one diagnostic struct to
 eliminate monomorphization of generic types

part of #3213
---
 crates/oxc_diagnostics/src/lib.rs             |  20 +-
 crates/oxc_linter/src/ast_util.rs             |   4 +-
 crates/oxc_linter/src/context.rs              |  10 +-
 crates/oxc_linter/src/disable_directives.rs   |  94 ++--
 crates/oxc_linter/src/lib.rs                  |   6 +-
 crates/oxc_linter/src/partial_loader/astro.rs |   8 +-
 crates/oxc_linter/src/partial_loader/vue.rs   |   8 +-
 .../deepscan/bad_array_method_on_arguments.rs |  49 +-
 .../rules/deepscan/bad_bitwise_operator.rs    |  46 +-
 .../rules/deepscan/bad_char_at_comparison.rs  |  29 +-
 .../rules/deepscan/bad_comparison_sequence.rs |  24 +-
 .../src/rules/deepscan/bad_min_max_func.rs    |  24 +-
 .../deepscan/bad_object_literal_comparison.rs |  33 +-
 .../src/rules/deepscan/bad_replace_all_arg.rs |  28 +-
 .../src/rules/deepscan/missing_throw.rs       |  28 +-
 .../rules/deepscan/number_arg_out_of_range.rs |  40 +-
 .../deepscan/uninvoked_array_callback.rs      |  39 +-
 .../rules/eslint/array_callback_return/mod.rs |  44 +-
 .../src/rules/eslint/constructor_super.rs     |   4 -
 .../src/rules/eslint/default_case_last.rs     |  25 +-
 .../src/rules/eslint/default_param_last.rs    |  17 +-
 crates/oxc_linter/src/rules/eslint/eqeqeq.rs  |  25 +-
 .../src/rules/eslint/for_direction.rs         |  30 +-
 .../src/rules/eslint/getter_return.rs         | 167 ++----
 .../src/rules/eslint/guard_for_in.rs          |  17 +-
 .../oxc_linter/src/rules/eslint/max_lines.rs  |  81 ++-
 .../oxc_linter/src/rules/eslint/max_params.rs |  40 +-
 .../src/rules/eslint/no_array_constructor.rs  |  17 +-
 .../rules/eslint/no_async_promise_executor.rs |  22 +-
 .../src/rules/eslint/no_await_in_loop.rs      |  16 +-
 .../oxc_linter/src/rules/eslint/no_bitwise.rs |  24 +-
 .../oxc_linter/src/rules/eslint/no_caller.rs  |  22 +-
 .../src/rules/eslint/no_case_declarations.rs  |  22 +-
 .../src/rules/eslint/no_class_assign.rs       |  29 +-
 .../src/rules/eslint/no_compare_neg_zero.rs   |  22 +-
 .../src/rules/eslint/no_cond_assign.rs        |  19 +-
 .../oxc_linter/src/rules/eslint/no_console.rs |  16 +-
 .../src/rules/eslint/no_const_assign.rs       |  29 +-
 .../eslint/no_constant_binary_expression.rs   |  63 ++-
 .../src/rules/eslint/no_constant_condition.rs |  19 +-
 .../src/rules/eslint/no_continue.rs           |  23 +-
 .../src/rules/eslint/no_control_regex.rs      |  23 +-
 .../src/rules/eslint/no_debugger.rs           |  16 +-
 .../src/rules/eslint/no_delete_var.rs         |  20 +-
 .../src/rules/eslint/no_dupe_class_members.rs |  34 +-
 .../src/rules/eslint/no_dupe_else_if.rs       |  34 +-
 .../src/rules/eslint/no_dupe_keys.rs          |  29 +-
 .../src/rules/eslint/no_duplicate_case.rs     | 127 ++---
 .../oxc_linter/src/rules/eslint/no_empty.rs   |  23 +-
 .../rules/eslint/no_empty_character_class.rs  |  17 +-
 .../src/rules/eslint/no_empty_function.rs     |  17 +-
 .../src/rules/eslint/no_empty_pattern.rs      |  20 +-
 .../src/rules/eslint/no_empty_static_block.rs |  17 +-
 .../oxc_linter/src/rules/eslint/no_eq_null.rs |  20 +-
 crates/oxc_linter/src/rules/eslint/no_eval.rs |  17 +-
 .../src/rules/eslint/no_ex_assign.rs          |  15 +-
 .../src/rules/eslint/no_extra_boolean_cast.rs |  38 +-
 .../src/rules/eslint/no_fallthrough.rs        |  34 +-
 .../src/rules/eslint/no_func_assign.rs        |  20 +-
 .../src/rules/eslint/no_global_assign.rs      |  24 +-
 .../src/rules/eslint/no_import_assign.rs      |  28 +-
 .../src/rules/eslint/no_inner_declarations.rs |  19 +-
 .../rules/eslint/no_irregular_whitespace.rs   |  17 +-
 .../src/rules/eslint/no_iterator.rs           |  21 +-
 .../src/rules/eslint/no_loss_of_precision.rs  |  26 +-
 .../eslint/no_new_native_nonconstructor.rs    |  30 +-
 .../src/rules/eslint/no_new_wrappers.rs       |  32 +-
 .../eslint/no_nonoctal_decimal_escape.rs      |  58 +-
 .../src/rules/eslint/no_obj_calls.rs          |  23 +-
 .../oxc_linter/src/rules/eslint/no_proto.rs   |  21 +-
 .../src/rules/eslint/no_prototype_builtins.rs |  37 +-
 .../src/rules/eslint/no_redeclare.rs          |  47 +-
 .../src/rules/eslint/no_regex_spaces.rs       |  21 +-
 .../src/rules/eslint/no_script_url.rs         |  17 +-
 .../src/rules/eslint/no_self_assign.rs        |  24 +-
 .../src/rules/eslint/no_self_compare.rs       |  26 +-
 .../src/rules/eslint/no_setter_return.rs      |  94 +---
 .../eslint/no_shadow_restricted_names.rs      |  58 +-
 .../src/rules/eslint/no_sparse_arrays.rs      |  31 +-
 .../eslint/no_template_curly_in_string.rs     |  22 +-
 .../oxc_linter/src/rules/eslint/no_ternary.rs |  17 +-
 .../src/rules/eslint/no_this_before_super.rs  |  75 +--
 .../oxc_linter/src/rules/eslint/no_undef.rs   |  21 +-
 .../src/rules/eslint/no_unsafe_finally.rs     | 125 +----
 .../src/rules/eslint/no_unsafe_negation.rs    |  22 +-
 .../eslint/no_unsafe_optional_chaining.rs     |  43 +-
 .../src/rules/eslint/no_unused_labels.rs      |  24 +-
 .../eslint/no_unused_private_class_members.rs |  22 +-
 .../src/rules/eslint/no_useless_catch.rs      |  48 +-
 .../src/rules/eslint/no_useless_escape.rs     |  17 +-
 .../src/rules/eslint/no_useless_rename.rs     |  35 +-
 crates/oxc_linter/src/rules/eslint/no_var.rs  |  17 +-
 crates/oxc_linter/src/rules/eslint/no_void.rs |  16 +-
 crates/oxc_linter/src/rules/eslint/no_with.rs |  17 +-
 crates/oxc_linter/src/rules/eslint/radix.rs   |  41 +-
 .../src/rules/eslint/require_yield.rs         |  16 +-
 .../oxc_linter/src/rules/eslint/use_isnan.rs  | 164 ++----
 .../src/rules/eslint/valid_typeof.rs          |  41 +-
 crates/oxc_linter/src/rules/import/default.rs |  19 +-
 crates/oxc_linter/src/rules/import/export.rs  |  48 +-
 crates/oxc_linter/src/rules/import/named.rs   |  27 +-
 .../oxc_linter/src/rules/import/namespace.rs  |  91 ++--
 crates/oxc_linter/src/rules/import/no_amd.rs  |  24 +-
 .../oxc_linter/src/rules/import/no_cycle.rs   |  16 +-
 .../src/rules/import/no_default_export.rs     |  16 +-
 .../src/rules/import/no_deprecated.rs         |   5 +-
 .../src/rules/import/no_duplicates.rs         |   8 +-
 .../src/rules/import/no_named_as_default.rs   |  21 +-
 .../import/no_named_as_default_member.rs      |  40 +-
 .../src/rules/import/no_self_import.rs        |  18 +-
 .../src/rules/import/no_unused_modules.rs     |  14 +-
 .../src/rules/jest/expect_expect.rs           |  82 +--
 .../oxc_linter/src/rules/jest/max_expects.rs  |  22 +-
 .../src/rules/jest/no_alias_methods.rs        |  17 +-
 .../src/rules/jest/no_commented_out_tests.rs  |  19 +-
 .../src/rules/jest/no_conditional_expect.rs   |  19 +-
 .../rules/jest/no_confusing_set_timeout.rs    |  53 +-
 .../src/rules/jest/no_deprecated_functions.rs |  19 +-
 .../src/rules/jest/no_disabled_tests.rs       |  43 +-
 .../src/rules/jest/no_done_callback.rs        |  37 +-
 crates/oxc_linter/src/rules/jest/no_export.rs |  19 +-
 .../src/rules/jest/no_focused_tests.rs        |  23 +-
 crates/oxc_linter/src/rules/jest/no_hooks.rs  |  16 +-
 .../src/rules/jest/no_identical_title.rs      |  24 +-
 .../jest/no_interpolation_in_snapshots.rs     |  21 +-
 .../src/rules/jest/no_jasmine_globals.rs      |  40 +-
 .../src/rules/jest/no_mocks_import.rs         |  22 +-
 .../rules/jest/no_restricted_jest_methods.rs  |  43 +-
 .../src/rules/jest/no_restricted_matchers.rs  |  37 +-
 .../src/rules/jest/no_standalone_expect.rs    |  52 +-
 .../src/rules/jest/no_test_prefixes.rs        |  35 +-
 .../rules/jest/no_test_return_statement.rs    |  17 +-
 .../src/rules/jest/no_untyped_mock_factory.rs |  27 +-
 .../src/rules/jest/prefer_called_with.rs      |  31 +-
 .../rules/jest/prefer_comparison_matcher.rs   |  19 +-
 .../src/rules/jest/prefer_equality_matcher.rs |  18 +-
 .../src/rules/jest/prefer_expect_resolves.rs  |  17 +-
 .../src/rules/jest/prefer_lowercase_title.rs  |  23 +-
 .../jest/prefer_mock_promise_shorthand.rs     |  22 +-
 .../src/rules/jest/prefer_spy_on.rs           |  58 +-
 .../src/rules/jest/prefer_strict_equal.rs     |  18 +-
 .../oxc_linter/src/rules/jest/prefer_to_be.rs |  58 +-
 .../src/rules/jest/prefer_to_contain.rs       |  21 +-
 .../src/rules/jest/prefer_to_have_length.rs   |  18 +-
 .../oxc_linter/src/rules/jest/prefer_todo.rs  |  28 +-
 .../oxc_linter/src/rules/jest/require_hook.rs |  21 +-
 .../rules/jest/require_to_throw_message.rs    |  19 +-
 .../src/rules/jest/valid_describe_callback.rs |  21 +-
 .../oxc_linter/src/rules/jest/valid_expect.rs | 176 +++---
 .../oxc_linter/src/rules/jest/valid_title.rs  |  39 +-
 .../src/rules/jsdoc/check_access.rs           |  36 +-
 .../src/rules/jsdoc/check_property_names.rs   |  49 +-
 .../src/rules/jsdoc/check_tag_names.rs        | 335 +++++++-----
 .../oxc_linter/src/rules/jsdoc/empty_tags.rs  |  48 +-
 .../src/rules/jsdoc/implements_on_classes.rs  |  19 +-
 .../oxc_linter/src/rules/jsdoc/no_defaults.rs |  43 +-
 .../src/rules/jsdoc/require_property.rs       |  23 +-
 .../jsdoc/require_property_description.rs     |  19 +-
 .../src/rules/jsdoc/require_property_name.rs  |  19 +-
 .../src/rules/jsdoc/require_property_type.rs  |  19 +-
 .../src/rules/jsdoc/require_yields.rs         |  45 +-
 .../oxc_linter/src/rules/jsx_a11y/alt_text.rs | 126 +++--
 .../src/rules/jsx_a11y/anchor_has_content.rs  |  33 +-
 .../src/rules/jsx_a11y/anchor_is_valid.rs     |  58 +-
 .../aria_activedescendant_has_tabindex.rs     |  20 +-
 .../src/rules/jsx_a11y/aria_props.rs          |  17 +-
 .../src/rules/jsx_a11y/aria_role.rs           |  30 +-
 .../jsx_a11y/aria_unsupported_elements.rs     |  17 +-
 .../src/rules/jsx_a11y/autocomplete_valid.rs  |  33 +-
 .../jsx_a11y/click_events_have_key_events.rs  |  17 +-
 .../src/rules/jsx_a11y/heading_has_content.rs |  20 +-
 .../src/rules/jsx_a11y/html_has_lang.rs       |  28 +-
 .../src/rules/jsx_a11y/iframe_has_title.rs    |  25 +-
 .../src/rules/jsx_a11y/img_redundant_alt.rs   |  23 +-
 crates/oxc_linter/src/rules/jsx_a11y/lang.rs  |  19 +-
 .../src/rules/jsx_a11y/media_has_caption.rs   |  26 +-
 .../jsx_a11y/mouse_events_have_key_events.rs  |  42 +-
 .../src/rules/jsx_a11y/no_access_key.rs       |  23 +-
 .../jsx_a11y/no_aria_hidden_on_focusable.rs   |  21 +-
 .../src/rules/jsx_a11y/no_autofocus.rs        |  19 +-
 .../rules/jsx_a11y/no_distracting_elements.rs |  26 +-
 .../src/rules/jsx_a11y/no_redundant_roles.rs  |  33 +-
 .../rules/jsx_a11y/prefer_tag_over_role.rs    |  30 +-
 .../jsx_a11y/role_has_required_aria_props.rs  |  43 +-
 .../jsx_a11y/role_supports_aria_props.rs      |  36 +-
 crates/oxc_linter/src/rules/jsx_a11y/scope.rs |  19 +-
 .../rules/jsx_a11y/tabindex_no_positive.rs    |  25 +-
 .../src/rules/nextjs/google_font_display.rs   |  72 ++-
 .../rules/nextjs/google_font_preconnect.rs    |  28 +-
 .../src/rules/nextjs/inline_script_id.rs      |  25 +-
 .../src/rules/nextjs/next_script_for_ga.rs    |  27 +-
 .../rules/nextjs/no_assign_module_variable.rs |  26 +-
 .../rules/nextjs/no_async_client_component.rs |  28 +-
 ...ore_interactive_script_outside_document.rs |  24 +-
 .../src/rules/nextjs/no_css_tags.rs           |  37 +-
 .../nextjs/no_document_import_in_page.rs      |  22 +-
 .../src/rules/nextjs/no_duplicate_head.rs     |  13 +-
 .../src/rules/nextjs/no_head_element.rs       |  25 +-
 .../nextjs/no_head_import_in_document.rs      |  22 +-
 .../src/rules/nextjs/no_img_element.rs        |  29 +-
 .../src/rules/nextjs/no_page_custom_font.rs   |  41 +-
 .../nextjs/no_script_component_in_head.rs     |  32 +-
 .../rules/nextjs/no_styled_jsx_in_document.rs |  25 +-
 .../src/rules/nextjs/no_sync_scripts.rs       |  54 +-
 .../rules/nextjs/no_title_in_document_head.rs |  32 +-
 .../oxc_linter/src/rules/nextjs/no_typos.rs   |  41 +-
 .../rules/nextjs/no_unwanted_polyfillio.rs    |  22 +-
 .../src/rules/oxc/approx_constant.rs          |  17 +-
 .../src/rules/oxc/const_comparisons.rs        |  87 ++-
 .../src/rules/oxc/double_comparisons.rs       |  22 +-
 crates/oxc_linter/src/rules/oxc/erasing_op.rs |  23 +-
 .../src/rules/oxc/misrefactored_assign_op.rs  |  23 +-
 .../src/rules/oxc/no_accumulating_spread.rs   |  60 ++-
 .../src/rules/oxc/no_barrel_file.rs           |  23 +-
 .../src/rules/oxc/only_used_in_recursion.rs   |  38 +-
 .../src/rules/react/button_has_type.rs        |  40 +-
 .../checked_requires_onchange_or_readonly.rs  |  58 +-
 crates/oxc_linter/src/rules/react/jsx_key.rs  |  59 +-
 .../rules/react/jsx_no_comment_textnodes.rs   |  19 +-
 .../src/rules/react/jsx_no_duplicate_props.rs |  38 +-
 .../src/rules/react/jsx_no_target_blank.rs    |  41 +-
 .../src/rules/react/jsx_no_undef.rs           |  21 +-
 .../rules/react/jsx_no_useless_fragment.rs    |  43 +-
 .../src/rules/react/no_children_prop.rs       |  28 +-
 .../oxc_linter/src/rules/react/no_danger.rs   |  27 +-
 .../rules/react/no_direct_mutation_state.rs   |  24 +-
 .../src/rules/react/no_find_dom_node.rs       |  31 +-
 .../src/rules/react/no_is_mounted.rs          |  17 +-
 .../src/rules/react/no_render_return_value.rs |  31 +-
 .../src/rules/react/no_string_refs.rs         |  28 +-
 .../src/rules/react/no_unescaped_entities.rs  |  20 +-
 .../src/rules/react/no_unknown_property.rs    |  61 +--
 .../src/rules/react/react_in_jsx_scope.rs     |  17 +-
 .../src/rules/react/require_render_return.rs  |  21 +-
 .../react/void_dom_elements_no_children.rs    |  23 +-
 .../rules/react_perf/jsx_no_jsx_as_prop.rs    |  19 +-
 .../react_perf/jsx_no_new_array_as_prop.rs    |  17 +-
 .../react_perf/jsx_no_new_function_as_prop.rs |  17 +-
 .../react_perf/jsx_no_new_object_as_prop.rs   |  17 +-
 .../listener_map.rs                           |  73 +--
 .../no_side_effects_in_initialization/mod.rs  | 110 ++--
 .../adjacent_overload_signatures.rs           |  35 +-
 .../src/rules/typescript/array_type.rs        |  96 ++--
 .../src/rules/typescript/ban_ts_comment.rs    | 508 +++++++++++-------
 .../rules/typescript/ban_tslint_comment.rs    |  18 +-
 .../src/rules/typescript/ban_types.rs         |  56 +-
 .../typescript/consistent_type_definitions.rs |  28 +-
 .../typescript/no_duplicate_enum_values.rs    |  32 +-
 .../rules/typescript/no_empty_interface.rs    |  29 +-
 .../src/rules/typescript/no_explicit_any.rs   |  27 +-
 .../typescript/no_extra_non_null_assertion.rs |  18 +-
 .../src/rules/typescript/no_misused_new.rs    |  42 +-
 .../src/rules/typescript/no_namespace.rs      |  34 +-
 .../no_non_null_asserted_optional_chain.rs    |  24 +-
 .../src/rules/typescript/no_this_alias.rs     |  46 +-
 .../no_unnecessary_type_constraint.rs         |  33 +-
 .../no_unsafe_declaration_merging.rs          |  17 +-
 .../src/rules/typescript/no_var_requires.rs   |  23 +-
 .../src/rules/typescript/prefer_as_const.rs   |  18 +-
 .../typescript/prefer_enum_initializers.rs    |  25 +-
 .../src/rules/typescript/prefer_for_of.rs     |  45 +-
 .../rules/typescript/prefer_function_type.rs  |  99 ++--
 .../typescript/prefer_literal_enum_member.rs  |  25 +-
 .../typescript/prefer_ts_expect_error.rs      |  24 +-
 .../typescript/triple_slash_reference.rs      |  31 +-
 .../src/rules/unicorn/catch_error_name.rs     |  51 +-
 .../src/rules/unicorn/empty_brace_spaces.rs   |  24 +-
 .../src/rules/unicorn/error_message.rs        |  48 +-
 .../src/rules/unicorn/escape_case.rs          |  21 +-
 .../rules/unicorn/explicit_length_check.rs    |  87 ++-
 .../src/rules/unicorn/filename_case.rs        |  22 +-
 .../src/rules/unicorn/new_for_builtins.rs     |  45 +-
 .../unicorn/no_abusive_eslint_disable.rs      |  19 +-
 .../src/rules/unicorn/no_array_for_each.rs    |  17 +-
 .../src/rules/unicorn/no_array_reduce.rs      |  19 +-
 .../unicorn/no_await_expression_member.rs     |  21 +-
 .../unicorn/no_await_in_promise_methods.rs    |  19 +-
 .../src/rules/unicorn/no_console_spaces.rs    |  23 +-
 .../src/rules/unicorn/no_document_cookie.rs   |  23 +-
 .../src/rules/unicorn/no_empty_file.rs        |  21 +-
 .../src/rules/unicorn/no_hex_escape.rs        |  24 +-
 .../src/rules/unicorn/no_instanceof_array.rs  |  21 +-
 .../no_invalid_remove_event_listener.rs       |  34 +-
 .../src/rules/unicorn/no_lonely_if.rs         |  21 +-
 .../src/rules/unicorn/no_negated_condition.rs |  26 +-
 .../src/rules/unicorn/no_nested_ternary.rs    |  51 +-
 .../src/rules/unicorn/no_new_array.rs         |  23 +-
 .../src/rules/unicorn/no_new_buffer.rs        |  24 +-
 .../oxc_linter/src/rules/unicorn/no_null.rs   |  36 +-
 .../unicorn/no_object_as_default_parameter.rs |  34 +-
 .../src/rules/unicorn/no_process_exit.rs      |  24 +-
 .../no_single_promise_in_promise_methods.rs   |  20 +-
 .../src/rules/unicorn/no_static_only_class.rs |  26 +-
 .../src/rules/unicorn/no_thenable.rs          |  56 +-
 .../src/rules/unicorn/no_this_assignment.rs   |  30 +-
 .../src/rules/unicorn/no_typeof_undefined.rs  |  27 +-
 .../src/rules/unicorn/no_unnecessary_await.rs |  24 +-
 .../no_unreadable_array_destructuring.rs      |  22 +-
 .../src/rules/unicorn/no_unreadable_iife.rs   |  24 +-
 .../unicorn/no_useless_fallback_in_spread.rs  |  33 +-
 .../rules/unicorn/no_useless_length_check.rs  |  40 +-
 .../no_useless_promise_resolve_reject.rs      |  53 +-
 .../src/rules/unicorn/no_useless_spread.rs    |  93 ++--
 .../rules/unicorn/no_useless_switch_case.rs   |  22 +-
 .../src/rules/unicorn/no_zero_fractions.rs    |  35 +-
 .../src/rules/unicorn/number_literal_case.rs  |  78 ++-
 .../rules/unicorn/numeric_separators_style.rs |  34 +-
 .../unicorn/prefer_add_event_listener.rs      |  23 +-
 .../src/rules/unicorn/prefer_array_flat.rs    |  25 +-
 .../rules/unicorn/prefer_array_flat_map.rs    |  25 +-
 .../src/rules/unicorn/prefer_array_some.rs    |  35 +-
 .../unicorn/prefer_blob_reading_methods.rs    |  23 +-
 .../src/rules/unicorn/prefer_code_point.rs    |  27 +-
 .../src/rules/unicorn/prefer_date_now.rs      |  73 ++-
 .../rules/unicorn/prefer_dom_node_append.rs   |  21 +-
 .../rules/unicorn/prefer_dom_node_dataset.rs  |  72 ++-
 .../rules/unicorn/prefer_dom_node_remove.rs   |  26 +-
 .../unicorn/prefer_dom_node_text_content.rs   |  23 +-
 .../src/rules/unicorn/prefer_event_target.rs  |  21 +-
 .../src/rules/unicorn/prefer_includes.rs      |  17 +-
 .../prefer_logical_operator_over_ternary.rs   |  25 +-
 .../src/rules/unicorn/prefer_math_trunc.rs    |  18 +-
 .../rules/unicorn/prefer_modern_dom_apis.rs   |  26 +-
 .../rules/unicorn/prefer_modern_math_apis.rs  |  57 +-
 .../prefer_native_coercion_functions.rs       |  70 +--
 .../src/rules/unicorn/prefer_node_protocol.rs |  17 +-
 .../rules/unicorn/prefer_number_properties.rs |  37 +-
 .../unicorn/prefer_optional_catch_binding.rs  |  19 +-
 .../rules/unicorn/prefer_prototype_methods.rs |  50 +-
 .../rules/unicorn/prefer_query_selector.rs    |  34 +-
 .../src/rules/unicorn/prefer_reflect_apply.rs |  23 +-
 .../src/rules/unicorn/prefer_regexp_test.rs   |  40 +-
 .../src/rules/unicorn/prefer_set_size.rs      |  15 +-
 .../src/rules/unicorn/prefer_spread.rs        |  47 +-
 .../unicorn/prefer_string_replace_all.rs      |  41 +-
 .../src/rules/unicorn/prefer_string_slice.rs  |  24 +-
 .../unicorn/prefer_string_starts_ends_with.rs |  33 +-
 .../unicorn/prefer_string_trim_start_end.rs   |  27 +-
 .../src/rules/unicorn/prefer_type_error.rs    |  37 +-
 .../unicorn/require_array_join_separator.rs   |  19 +-
 ...require_number_to_fixed_digits_argument.rs |  17 +-
 .../src/rules/unicorn/switch_case_braces.rs   |  78 +--
 .../unicorn/text_encoding_identifier_case.rs  |  32 +-
 .../src/rules/unicorn/throw_new_error.rs      |  24 +-
 crates/oxc_linter/src/service.rs              |   4 +-
 .../src/snapshots/array_callback_return.snap  |  80 +--
 .../oxc_linter/src/snapshots/max_lines.snap   |  46 +-
 .../oxc_linter/src/snapshots/namespace.snap   |   3 +-
 .../src/snapshots/no_setter_return.snap       |  84 +--
 .../no_useless_promise_resolve_reject.snap    |   2 +-
 crates/oxc_linter/src/tester.rs               |   3 +-
 .../src/utils/jest/parse_jest_fn.rs           |   4 +-
 crates/oxc_linter/src/utils/nextjs.rs         |   4 +-
 crates/oxc_linter/src/utils/react.rs          |  16 +-
 .../oxc_linter/src/utils/unicorn/boolean.rs   |   8 +-
 355 files changed, 5930 insertions(+), 6437 deletions(-)

diff --git a/crates/oxc_diagnostics/src/lib.rs b/crates/oxc_diagnostics/src/lib.rs
index aa86aeaaa8b1..b5fc721e6c59 100644
--- a/crates/oxc_diagnostics/src/lib.rs
+++ b/crates/oxc_diagnostics/src/lib.rs
@@ -27,8 +27,8 @@ pub type Report = miette::Report;
 
 pub type Result<T> = std::result::Result<T, OxcDiagnostic>;
 
-pub use miette::LabeledSpan;
 use miette::{Diagnostic, SourceCode};
+pub use miette::{LabeledSpan, NamedSource};
 use thiserror::Error;
 
 #[derive(Debug, Error, Diagnostic)]
@@ -60,6 +60,7 @@ pub struct OxcDiagnosticInner {
     pub message: String,
     pub labels: Option<Vec<LabeledSpan>>,
     pub help: Option<String>,
+    pub severity: Severity,
 }
 
 impl fmt::Display for OxcDiagnostic {
@@ -75,6 +76,10 @@ impl Diagnostic for OxcDiagnostic {
         self.help.as_ref().map(Box::new).map(|c| c as Box<dyn Display>)
     }
 
+    fn severity(&self) -> Option<Severity> {
+        Some(self.severity)
+    }
+
     fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>> {
         self.labels
             .as_ref()
@@ -92,6 +97,19 @@ impl OxcDiagnostic {
                 message: message.into(),
                 labels: None,
                 help: None,
+                severity: Severity::Error,
+            }),
+        }
+    }
+
+    #[must_use]
+    pub fn warning<T: Into<String>>(message: T) -> Self {
+        Self {
+            inner: Box::new(OxcDiagnosticInner {
+                message: message.into(),
+                labels: None,
+                help: None,
+                severity: Severity::Warning,
             }),
         }
     }
diff --git a/crates/oxc_linter/src/ast_util.rs b/crates/oxc_linter/src/ast_util.rs
index e3cffb73ebe7..f237bd5dd8df 100644
--- a/crates/oxc_linter/src/ast_util.rs
+++ b/crates/oxc_linter/src/ast_util.rs
@@ -318,7 +318,9 @@ pub fn is_method_call<'a>(
     }
 
     if let Some(methods) = methods {
-        let Some(static_property_name) = member_expr.static_property_name() else { return false };
+        let Some(static_property_name) = member_expr.static_property_name() else {
+            return false;
+        };
         if !methods.contains(&static_property_name) {
             return false;
         }
diff --git a/crates/oxc_linter/src/context.rs b/crates/oxc_linter/src/context.rs
index 9caded75006c..747982263fbe 100644
--- a/crates/oxc_linter/src/context.rs
+++ b/crates/oxc_linter/src/context.rs
@@ -1,7 +1,7 @@
 use std::{cell::RefCell, path::Path, rc::Rc, sync::Arc};
 
 use oxc_codegen::{Codegen, CodegenOptions};
-use oxc_diagnostics::Error;
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_semantic::{AstNodes, JSDocFinder, ScopeTree, Semantic, SymbolTable};
 use oxc_span::SourceType;
 
@@ -116,15 +116,11 @@ impl<'a> LintContext<'a> {
         }
     }
 
-    pub fn diagnostic<T: Into<Error>>(&self, diagnostic: T) {
+    pub fn diagnostic(&self, diagnostic: OxcDiagnostic) {
         self.add_diagnostic(Message::new(diagnostic.into(), None));
     }
 
-    pub fn diagnostic_with_fix<T, F>(&self, diagnostic: T, fix: F)
-    where
-        T: Into<Error>,
-        F: FnOnce() -> Fix<'a>,
-    {
+    pub fn diagnostic_with_fix<F: FnOnce() -> Fix<'a>>(&self, diagnostic: OxcDiagnostic, fix: F) {
         if self.fix {
             self.add_diagnostic(Message::new(diagnostic.into(), Some(fix())));
         } else {
diff --git a/crates/oxc_linter/src/disable_directives.rs b/crates/oxc_linter/src/disable_directives.rs
index d461e7c4c9a1..5b87462f22a3 100644
--- a/crates/oxc_linter/src/disable_directives.rs
+++ b/crates/oxc_linter/src/disable_directives.rs
@@ -214,36 +214,45 @@ fn test() {
         // [Disabling Rules](https://eslint.org/docs/latest/use/configure/rules#disabling-rules)
         // Using configuration comments
         let pass = vec![
-        // To disable rule warnings in a part of a file, use block comments in the following format:
-        format!("
+            // To disable rule warnings in a part of a file, use block comments in the following format:
+            format!(
+                "
         /* {prefix}-disable */
             debugger;
         /* {prefix}-enable */
-        "),
-        // You can also disable or enable warnings for specific rules:
-        format!("
+        "
+            ),
+            // You can also disable or enable warnings for specific rules:
+            format!(
+                "
         /* {prefix}-disable no-debugger, no-console */
             debugger;
         /* {prefix}-enable no-debugger, no-console */
-        "),
-        // To disable rule warnings in an entire file, put a /* eslint-disable */ block comment at the top of the file:
-        format!("
+        "
+            ),
+            // To disable rule warnings in an entire file, put a /* eslint-disable */ block comment at the top of the file:
+            format!(
+                "
         /* {prefix}-disable */
             debugger;
-        "),
-        // You can also disable or enable specific rules for an entire file:
-        format!("
+        "
+            ),
+            // You can also disable or enable specific rules for an entire file:
+            format!(
+                "
         /* {prefix}-disable no-debugger */
             debugger;
-        "),
-        // To ensure that a rule is never applied (regardless of any future enable/disable lines):
-        // This is not supported.
-        // "
-        // /* eslint no-debugger: \"off\" */
-        //     debugger;
-        // "),
-        // To disable all rules on a specific line, use a line or block comment in one of the following formats:
-        format!("debugger; // {prefix}-disable-line
+        "
+            ),
+            // To ensure that a rule is never applied (regardless of any future enable/disable lines):
+            // This is not supported.
+            // "
+            // /* eslint no-debugger: \"off\" */
+            //     debugger;
+            // "),
+            // To disable all rules on a specific line, use a line or block comment in one of the following formats:
+            format!(
+                "debugger; // {prefix}-disable-line
             debugger; // {prefix}-disable-line
 
             // {prefix}-disable-next-line
@@ -253,9 +262,11 @@ fn test() {
             debugger;
 
             debugger; /* {prefix}-disable-line */
-        "),
-        // To disable a specific rule on a specific line:
-        format!("
+        "
+            ),
+            // To disable a specific rule on a specific line:
+            format!(
+                "
             debugger; // {prefix}-disable-line no-debugger
 
             // {prefix}-disable-next-line no-debugger
@@ -265,9 +276,11 @@ fn test() {
 
             /* {prefix}-disable-next-line no-debugger */
             debugger;
-        "),
-        // To disable multiple rules on a specific line:
-        format!("
+        "
+            ),
+            // To disable multiple rules on a specific line:
+            format!(
+                "
             debugger; // {prefix}-disable-line no-debugger, quotes, semi
 
             // {prefix}-disable-next-line no-debugger, quotes, semi
@@ -284,23 +297,29 @@ fn test() {
               semi
             */
             debugger;
-        "),
-        // To disable all rules twice:
-        format!("
+        "
+            ),
+            // To disable all rules twice:
+            format!(
+                "
         /* {prefix}-disable */
             debugger;
         /* {prefix}-disable */
             debugger;
-        "),
-        // To disable a rule twice:
-        format!("
+        "
+            ),
+            // To disable a rule twice:
+            format!(
+                "
         /* {prefix}-disable no-debugger */
             debugger;
         /* {prefix}-disable no-debugger */
             debugger;
-        "),
-        // Comment descriptions
-        format!("
+        "
+            ),
+            // Comment descriptions
+            format!(
+                "
             // {prefix}-disable-next-line no-debugger -- Here's a description about why this configuration is necessary.
             debugger;
 
@@ -309,8 +328,9 @@ fn test() {
              * along with some additional information
             **/
             debugger;
-        ")
-    ];
+        "
+            ),
+        ];
 
         let fail = vec![
             "debugger".to_string(),
diff --git a/crates/oxc_linter/src/lib.rs b/crates/oxc_linter/src/lib.rs
index f22fa1e52b73..0e2a5be02d3f 100644
--- a/crates/oxc_linter/src/lib.rs
+++ b/crates/oxc_linter/src/lib.rs
@@ -163,11 +163,7 @@ impl Linter {
                 } else {
                     ("", 7)
                 };
-                writeln!(
-                    writer,
-                    "| {rule_name:<rule_width$} | {plugin_name:<plugin_width$} | {default:<default_width$} |"
-                )
-                .unwrap();
+                writeln!(writer, "| {rule_name:<rule_width$} | {plugin_name:<plugin_width$} | {default:<default_width$} |").unwrap();
             }
             writeln!(writer).unwrap();
         }
diff --git a/crates/oxc_linter/src/partial_loader/astro.rs b/crates/oxc_linter/src/partial_loader/astro.rs
index cb45ab183695..45ea8cb99146 100644
--- a/crates/oxc_linter/src/partial_loader/astro.rs
+++ b/crates/oxc_linter/src/partial_loader/astro.rs
@@ -35,8 +35,12 @@ impl<'a> AstroPartialLoader<'a> {
 
         let start = offsets.first()?;
         let end = offsets.last()?;
-        let Ok(start) = u32::try_from(*start) else { return None };
-        let Ok(end) = u32::try_from(*end) else { return None };
+        let Ok(start) = u32::try_from(*start) else {
+            return None;
+        };
+        let Ok(end) = u32::try_from(*end) else {
+            return None;
+        };
 
         let js_code =
             Span::new(start + ASTRO_SPLIT.len() as u32, end).source_text(self.source_text);
diff --git a/crates/oxc_linter/src/partial_loader/vue.rs b/crates/oxc_linter/src/partial_loader/vue.rs
index 4132f0b8a241..30492de81637 100644
--- a/crates/oxc_linter/src/partial_loader/vue.rs
+++ b/crates/oxc_linter/src/partial_loader/vue.rs
@@ -23,8 +23,12 @@ impl<'a> VuePartialLoader<'a> {
     /// <https://vuejs.org/api/sfc-spec.html#script>
     fn parse_scripts(&self) -> Vec<JavaScriptSource<'a>> {
         let mut pointer = 0;
-        let Some(result1) = self.parse_script(&mut pointer) else { return vec![] };
-        let Some(result2) = self.parse_script(&mut pointer) else { return vec![result1] };
+        let Some(result1) = self.parse_script(&mut pointer) else {
+            return vec![];
+        };
+        let Some(result2) = self.parse_script(&mut pointer) else {
+            return vec![result1];
+        };
         vec![result1, result2]
     }
 
diff --git a/crates/oxc_linter/src/rules/deepscan/bad_array_method_on_arguments.rs b/crates/oxc_linter/src/rules/deepscan/bad_array_method_on_arguments.rs
index 65650f419dfe..66144fefca6f 100644
--- a/crates/oxc_linter/src/rules/deepscan/bad_array_method_on_arguments.rs
+++ b/crates/oxc_linter/src/rules/deepscan/bad_array_method_on_arguments.rs
@@ -2,24 +2,20 @@ use oxc_ast::{
     ast::{Expression, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("deepscan(bad-array-method-on-arguments): Bad array method on arguments")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "The 'arguments' object does not have '{0}()' method. If an array method was intended, consider converting the 'arguments' object to an array or using ES6 rest parameter instead."
-    )
-)]
-struct BadArrayMethodOnArgumentsDiagnostic(CompactStr, #[label] pub Span);
+fn bad_array_method_on_arguments_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("deepscan(bad-array-method-on-arguments): Bad array method on arguments")
+        .with_help(format!(
+            "The 'arguments' object does not have '{x0}()' method. If an array method was intended, consider converting the 'arguments' object to an array or using ES6 rest parameter instead."
+        ))
+        .with_labels([span1.into()])
+}
 
 /// `https://deepscan.io/docs/rules/bad-array-method-on-arguments`
 #[derive(Debug, Default, Clone)]
@@ -51,17 +47,23 @@ impl Rule for BadArrayMethodOnArguments {
         if !node.kind().is_specific_id_reference("arguments") {
             return;
         }
-        let Some(parent_node_id) = ctx.nodes().parent_id(node.id()) else { return };
+        let Some(parent_node_id) = ctx.nodes().parent_id(node.id()) else {
+            return;
+        };
         let AstKind::MemberExpression(member_expr) = ctx.nodes().kind(parent_node_id) else {
             return;
         };
-        let Some(parent_node_id) = ctx.nodes().parent_id(parent_node_id) else { return };
-        let AstKind::CallExpression(_) = ctx.nodes().kind(parent_node_id) else { return };
+        let Some(parent_node_id) = ctx.nodes().parent_id(parent_node_id) else {
+            return;
+        };
+        let AstKind::CallExpression(_) = ctx.nodes().kind(parent_node_id) else {
+            return;
+        };
         match member_expr {
             MemberExpression::StaticMemberExpression(expr) => {
                 if ARRAY_METHODS.binary_search(&expr.property.name.as_str()).is_ok() {
-                    ctx.diagnostic(BadArrayMethodOnArgumentsDiagnostic(
-                        expr.property.name.to_compact_str(),
+                    ctx.diagnostic(bad_array_method_on_arguments_diagnostic(
+                        expr.property.name.as_str(),
                         expr.span,
                     ));
                 }
@@ -70,8 +72,8 @@ impl Rule for BadArrayMethodOnArguments {
                 match &expr.expression {
                     Expression::StringLiteral(name) => {
                         if ARRAY_METHODS.binary_search(&name.value.as_str()).is_ok() {
-                            ctx.diagnostic(BadArrayMethodOnArgumentsDiagnostic(
-                                name.value.to_compact_str(),
+                            ctx.diagnostic(bad_array_method_on_arguments_diagnostic(
+                                name.value.as_str(),
                                 expr.span,
                             ));
                         }
@@ -85,9 +87,8 @@ impl Rule for BadArrayMethodOnArguments {
                                 })
                             {
                                 if ARRAY_METHODS.binary_search(&name).is_ok() {
-                                    ctx.diagnostic(BadArrayMethodOnArgumentsDiagnostic(
-                                        CompactStr::from(name),
-                                        expr.span,
+                                    ctx.diagnostic(bad_array_method_on_arguments_diagnostic(
+                                        name, expr.span,
                                     ));
                                 }
                             }
diff --git a/crates/oxc_linter/src/rules/deepscan/bad_bitwise_operator.rs b/crates/oxc_linter/src/rules/deepscan/bad_bitwise_operator.rs
index 1d622a1c838c..ab68f155e98c 100644
--- a/crates/oxc_linter/src/rules/deepscan/bad_bitwise_operator.rs
+++ b/crates/oxc_linter/src/rules/deepscan/bad_bitwise_operator.rs
@@ -2,33 +2,27 @@ use oxc_ast::{
     ast::{BinaryExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, UnaryOperator};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("deepscan(bad-bitwise-operator): Bad bitwise operator")]
-#[diagnostic(
-    severity(warning),
-    help("Bitwise operator '{0}' seems unintended. Did you mean logical operator '{1}'?")
-)]
-struct BadBitwiseOperatorDiagnostic(&'static str, &'static str, #[label] pub Span);
-
-#[derive(Debug, Error, Diagnostic)]
-#[error("Bad bitwise operator")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "Bitwise operator '|=' seems unintended. Consider using non-compound assignment and logical operator '||' instead."
-    )
-)]
-struct BadBitwiseOrOperatorDiagnostic(#[label] pub Span);
+fn bad_bitwise_operator_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("deepscan(bad-bitwise-operator): Bad bitwise operator")
+        .with_help(format!(
+            "Bitwise operator '{x0}' seems unintended. Did you mean logical operator '{x1}'?"
+        ))
+        .with_labels([span2.into()])
+}
+
+fn bad_bitwise_or_operator_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("Bad bitwise operator")
+        .with_help("Bitwise operator '|=' seems unintended. Consider using non-compound assignment and logical operator '||' instead.")
+        .with_labels([span0.into()])
+}
 
 /// `https://deepscan.io/docs/rules/bad-bitwise-operator`
 #[derive(Debug, Default, Clone)]
@@ -67,16 +61,16 @@ impl Rule for BadBitwiseOperator {
         match node.kind() {
             AstKind::BinaryExpression(bin_expr) => {
                 if is_mistype_short_circuit(node) {
-                    ctx.diagnostic(BadBitwiseOperatorDiagnostic("&", "&&", bin_expr.span));
+                    ctx.diagnostic(bad_bitwise_operator_diagnostic("&", "&&", bin_expr.span));
                 } else if is_mistype_option_fallback(node) {
-                    ctx.diagnostic(BadBitwiseOperatorDiagnostic("|", "||", bin_expr.span));
+                    ctx.diagnostic(bad_bitwise_operator_diagnostic("|", "||", bin_expr.span));
                 }
             }
             AstKind::AssignmentExpression(assign_expr) => {
                 if assign_expr.operator == AssignmentOperator::BitwiseOR
                     && !is_numeric_expr(&assign_expr.right, true)
                 {
-                    ctx.diagnostic(BadBitwiseOrOperatorDiagnostic(assign_expr.span));
+                    ctx.diagnostic(bad_bitwise_or_operator_diagnostic(assign_expr.span));
                 }
             }
             _ => {}
@@ -91,7 +85,9 @@ fn is_mistype_short_circuit(node: &AstNode) -> bool {
                 return false;
             }
 
-            let Expression::Identifier(left_ident) = &bin_expr.left else { return false };
+            let Expression::Identifier(left_ident) = &bin_expr.left else {
+                return false;
+            };
 
             if let Some(member_expr) = bin_expr.right.as_member_expression() {
                 if let Expression::Identifier(ident) = member_expr.object() {
diff --git a/crates/oxc_linter/src/rules/deepscan/bad_char_at_comparison.rs b/crates/oxc_linter/src/rules/deepscan/bad_char_at_comparison.rs
index 6eb1366339f4..15dc332ebb65 100644
--- a/crates/oxc_linter/src/rules/deepscan/bad_char_at_comparison.rs
+++ b/crates/oxc_linter/src/rules/deepscan/bad_char_at_comparison.rs
@@ -1,22 +1,17 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::BinaryOperator;
 
 use crate::{ast_util::is_method_call, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("deepscan(bad-char-at-comparison): Invalid comparison with `charAt` method")]
-#[diagnostic(severity(warning), help("`String.prototype.charAt` returns a string of length 1. If the return value is compared with a string of length greater than 1, the comparison will always be false."))]
-struct BadCharAtComparisonDiagnostic(
-    #[label("`charAt` called here")] pub Span,
-    #[label("And compared with a string of length {2} here")] pub Span,
-    usize,
-);
+fn bad_char_at_comparison_diagnostic(span0: Span, span1: Span, x2: usize) -> OxcDiagnostic {
+    OxcDiagnostic::warning("deepscan(bad-char-at-comparison): Invalid comparison with `charAt` method")
+        .with_help("`String.prototype.charAt` returns a string of length 1. If the return value is compared with a string of length greater than 1, the comparison will always be false.")
+        .with_labels([LabeledSpan::new_with_span(Some("`charAt` called here".into()), span0), LabeledSpan::new_with_span(Some(format!("And compared with a string of length {x2} here")), span1)])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct BadCharAtComparison;
@@ -46,7 +41,9 @@ declare_oxc_lint!(
 
 impl Rule for BadCharAtComparison {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
         if !is_method_call(call_expr, None, Some(&["charAt"]), Some(1), Some(1)) {
             return;
@@ -56,7 +53,9 @@ impl Rule for BadCharAtComparison {
             return;
         };
 
-        let AstKind::BinaryExpression(binary_expr) = parent.kind() else { return };
+        let AstKind::BinaryExpression(binary_expr) = parent.kind() else {
+            return;
+        };
         if !matches!(
             binary_expr.operator,
             BinaryOperator::Equality
@@ -75,7 +74,7 @@ impl Rule for BadCharAtComparison {
 
         if let Expression::StringLiteral(string_lit) = comparison_with {
             if !is_string_valid(string_lit.value.as_str()) {
-                ctx.diagnostic(BadCharAtComparisonDiagnostic(
+                ctx.diagnostic(bad_char_at_comparison_diagnostic(
                     call_expr.span,
                     string_lit.span,
                     string_lit.value.len(),
diff --git a/crates/oxc_linter/src/rules/deepscan/bad_comparison_sequence.rs b/crates/oxc_linter/src/rules/deepscan/bad_comparison_sequence.rs
index 3620944fab4b..51d3a515a669 100644
--- a/crates/oxc_linter/src/rules/deepscan/bad_comparison_sequence.rs
+++ b/crates/oxc_linter/src/rules/deepscan/bad_comparison_sequence.rs
@@ -2,24 +2,16 @@ use oxc_ast::{
     ast::{BinaryExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("deepscan(bad-comparison-sequence): Bad comparison sequence")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "Comparison result should not be used directly as an operand of another comparison. If you need to compare three or more operands, you should connect each comparison operation with logical AND operator (`&&`)"
-    )
-)]
-struct BadComparisonSequenceDiagnostic(#[label] pub Span);
+fn bad_comparison_sequence_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("deepscan(bad-comparison-sequence): Bad comparison sequence").with_help("Comparison result should not be used directly as an operand of another comparison. If you need to compare three or more operands, you should connect each comparison operation with logical AND operator (`&&`)").with_labels([span0.into()])
+}
 
 /// `https://deepscan.io/docs/rules/bad-comparison-sequence`
 #[derive(Debug, Default, Clone)]
@@ -45,9 +37,11 @@ declare_oxc_lint!(
 
 impl Rule for BadComparisonSequence {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::BinaryExpression(expr) = node.kind() else { return };
+        let AstKind::BinaryExpression(expr) = node.kind() else {
+            return;
+        };
         if is_bad_comparison(expr) && has_no_bad_comparison_in_parents(node, ctx) {
-            ctx.diagnostic(BadComparisonSequenceDiagnostic(expr.span));
+            ctx.diagnostic(bad_comparison_sequence_diagnostic(expr.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/deepscan/bad_min_max_func.rs b/crates/oxc_linter/src/rules/deepscan/bad_min_max_func.rs
index f9c2f022b86d..fe8d1ac7d940 100644
--- a/crates/oxc_linter/src/rules/deepscan/bad_min_max_func.rs
+++ b/crates/oxc_linter/src/rules/deepscan/bad_min_max_func.rs
@@ -2,22 +2,22 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("deepscan(bad-min-max-func): Math.min and Math.max combination leads to constant result")]
-#[diagnostic(
-    severity(warning),
-    help("This evaluates to {0:?} because of the incorrect `Math.min`/`Math.max` combination")
-)]
-struct BadMinMaxFuncDiagnostic(f64, #[label] pub Span);
+fn bad_min_max_func_diagnostic(x0: f64, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "deepscan(bad-min-max-func): Math.min and Math.max combination leads to constant result",
+    )
+    .with_help(format!(
+        "This evaluates to {x0:?} because of the incorrect `Math.min`/`Math.max` combination"
+    ))
+    .with_labels([span1.into()])
+}
 
 /// `https://deepscan.io/docs/rules/bad-min-max-func`
 #[derive(Debug, Default, Clone)]
@@ -66,7 +66,7 @@ impl Rule for BadMinMaxFunc {
                     };
 
                     if let Some(constant) = constant_result {
-                        ctx.diagnostic(BadMinMaxFuncDiagnostic(*constant, call_expr.span));
+                        ctx.diagnostic(bad_min_max_func_diagnostic(*constant, call_expr.span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/deepscan/bad_object_literal_comparison.rs b/crates/oxc_linter/src/rules/deepscan/bad_object_literal_comparison.rs
index a8a87ce1f34c..1e0aee81c1d4 100644
--- a/crates/oxc_linter/src/rules/deepscan/bad_object_literal_comparison.rs
+++ b/crates/oxc_linter/src/rules/deepscan/bad_object_literal_comparison.rs
@@ -1,22 +1,23 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::BinaryOperator;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum BadObjectLiteralComparisonDiagnostic {
-    #[error("deepscan(bad-object-literal-comparison): Unexpected object literal comparison.")]
-    #[diagnostic(severity(warning), help("This comparison will always return {1:?} as object literals are never equal to each other. Consider using `Object.entries()` of `Object.keys()` and comparing their lengths."))]
-    ObjectComparison(#[label] Span, bool),
-    #[error("deepscan(bad-object-literal-comparison): Unexpected array literal comparison.")]
-    #[diagnostic(severity(warning), help("This comparison will always return {1:?} as array literals are never equal to each other. Consider using `Array.length` if empty checking was intended."))]
-    ArrayComparison(#[label] Span, bool),
+fn object_comparison(span0: Span, x1: bool) -> OxcDiagnostic {
+    OxcDiagnostic::warning("deepscan(bad-object-literal-comparison): Unexpected object literal comparison.")
+        .with_help(format!(
+            "This comparison will always return {x1:?} as object literals are never equal to each other. Consider using `Object.entries()` of `Object.keys()` and comparing their lengths."
+        ))
+        .with_labels([span0.into()])
+}
+
+fn array_comparison(span0: Span, x1: bool) -> OxcDiagnostic {
+    OxcDiagnostic::warning("deepscan(bad-object-literal-comparison): Unexpected array literal comparison.")
+        .with_help(format!("This comparison will always return {x1:?} as array literals are never equal to each other. Consider using `Array.length` if empty checking was intended."))
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -50,7 +51,9 @@ declare_oxc_lint!(
 
 impl Rule for BadObjectLiteralComparison {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::BinaryExpression(binary_expression) = node.kind() else { return };
+        let AstKind::BinaryExpression(binary_expression) = node.kind() else {
+            return;
+        };
 
         if !matches!(
             binary_expression.operator,
@@ -65,7 +68,7 @@ impl Rule for BadObjectLiteralComparison {
         if is_empty_object_expression(&binary_expression.left)
             || is_empty_object_expression(&binary_expression.right)
         {
-            ctx.diagnostic(BadObjectLiteralComparisonDiagnostic::ObjectComparison(
+            ctx.diagnostic(object_comparison(
                 binary_expression.span,
                 matches!(
                     binary_expression.operator,
@@ -77,7 +80,7 @@ impl Rule for BadObjectLiteralComparison {
         if is_empty_array_expression(&binary_expression.left)
             || is_empty_array_expression(&binary_expression.right)
         {
-            ctx.diagnostic(BadObjectLiteralComparisonDiagnostic::ArrayComparison(
+            ctx.diagnostic(array_comparison(
                 binary_expression.span,
                 matches!(
                     binary_expression.operator,
diff --git a/crates/oxc_linter/src/rules/deepscan/bad_replace_all_arg.rs b/crates/oxc_linter/src/rules/deepscan/bad_replace_all_arg.rs
index f9160faf7e80..8a5fd85910e6 100644
--- a/crates/oxc_linter/src/rules/deepscan/bad_replace_all_arg.rs
+++ b/crates/oxc_linter/src/rules/deepscan/bad_replace_all_arg.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Expression, RegExpFlags},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,13 +14,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("deepscan(bad-replace-all-arg): Global flag (g) is missing in the regular expression supplied to the `replaceAll` method.")]
-#[diagnostic(severity(warning), help("To replace all occurrences of a string, use the `replaceAll` method with the global flag (g) in the regular expression."))]
-struct BadReplaceAllArgDiagnostic(
-    #[label("`replaceAll` called here")] pub Span,
-    #[label("RegExp supplied here")] pub Span,
-);
+fn bad_replace_all_arg_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("deepscan(bad-replace-all-arg): Global flag (g) is missing in the regular expression supplied to the `replaceAll` method.")
+        .with_help("To replace all occurrences of a string, use the `replaceAll` method with the global flag (g) in the regular expression.")
+        .with_labels([LabeledSpan::new_with_span(Some("`replaceAll` called here".into()), span0), LabeledSpan::new_with_span(Some("RegExp supplied here".into()), span1)])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct BadReplaceAllArg;
@@ -50,7 +46,9 @@ declare_oxc_lint!(
 
 impl Rule for BadReplaceAllArg {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
         if !is_method_call(call_expr, None, Some(&["replaceAll"]), Some(1), None) {
             return;
@@ -65,12 +63,14 @@ impl Rule for BadReplaceAllArg {
         };
 
         if !flags.contains(RegExpFlags::G) {
-            let Some(call_expr_callee) = call_expr.callee.as_member_expression() else { return };
+            let Some(call_expr_callee) = call_expr.callee.as_member_expression() else {
+                return;
+            };
             let Some((replace_all_span, _)) = call_expr_callee.static_property_info() else {
                 return;
             };
 
-            ctx.diagnostic(BadReplaceAllArgDiagnostic(replace_all_span, regex_span));
+            ctx.diagnostic(bad_replace_all_arg_diagnostic(replace_all_span, regex_span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/deepscan/missing_throw.rs b/crates/oxc_linter/src/rules/deepscan/missing_throw.rs
index 84c038e425a7..64a6f3464a45 100644
--- a/crates/oxc_linter/src/rules/deepscan/missing_throw.rs
+++ b/crates/oxc_linter/src/rules/deepscan/missing_throw.rs
@@ -1,20 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("deepscan(missing-throw): Missing throw")]
-#[diagnostic(
-    severity(warning),
-    help("The `throw` keyword seems to be missing in front of this 'new' expression")
-)]
-struct MissingThrowDiagnostic(#[label] pub Span);
+fn missing_throw_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("deepscan(missing-throw): Missing throw")
+        .with_help("The `throw` keyword seems to be missing in front of this 'new' expression")
+        .with_labels([span0.into()])
+}
 
 /// `https://deepscan.io/docs/rules/missing-throw`
 #[derive(Debug, Default, Clone)]
@@ -36,9 +32,11 @@ declare_oxc_lint!(
 
 impl Rule for MissingThrow {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::NewExpression(new_expr) = node.kind() else { return };
+        let AstKind::NewExpression(new_expr) = node.kind() else {
+            return;
+        };
         if new_expr.callee.is_specific_id("Error") && Self::has_missing_throw(node, ctx) {
-            ctx.diagnostic(MissingThrowDiagnostic(new_expr.span));
+            ctx.diagnostic(missing_throw_diagnostic(new_expr.span));
         }
     }
 }
@@ -47,7 +45,9 @@ impl MissingThrow {
     fn has_missing_throw<'a>(node: &AstNode<'a>, ctx: &LintContext<'a>) -> bool {
         let mut node_ancestors = ctx.nodes().ancestors(node.id()).skip(1);
 
-        let Some(node_id) = node_ancestors.next() else { return false };
+        let Some(node_id) = node_ancestors.next() else {
+            return false;
+        };
 
         if matches!(ctx.nodes().kind(node_id), AstKind::ExpressionStatement(_)) {
             for node_id in node_ancestors {
diff --git a/crates/oxc_linter/src/rules/deepscan/number_arg_out_of_range.rs b/crates/oxc_linter/src/rules/deepscan/number_arg_out_of_range.rs
index e24ea9f44549..1813bfab375c 100644
--- a/crates/oxc_linter/src/rules/deepscan/number_arg_out_of_range.rs
+++ b/crates/oxc_linter/src/rules/deepscan/number_arg_out_of_range.rs
@@ -1,20 +1,21 @@
 use oxc_ast::{ast::Argument, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("deepscan(number-arg-out-of-range): Radix or precision arguments of number-related functions should not exceed the limit")]
-#[diagnostic(
-    severity(warning),
-    help("The first argument of 'Number.prototype.{0}' should be a number between {1} and {2}")
-)]
-struct NumberArgOutOfRangeDiagnostic(CompactStr, usize, usize, #[label] pub Span);
+fn number_arg_out_of_range_diagnostic(
+    x0: &str,
+    x1: usize,
+    x2: usize,
+    span3: Span,
+) -> OxcDiagnostic {
+    OxcDiagnostic::warning("deepscan(number-arg-out-of-range): Radix or precision arguments of number-related functions should not exceed the limit")
+        .with_help(format!("The first argument of 'Number.prototype.{x0}' should be a number between {x1} and {x2}"))
+        .with_labels([span3.into()])
+}
 
 /// `https://deepscan.io/docs/rules/number-arg-out-of-range`
 #[derive(Debug, Default, Clone)]
@@ -47,20 +48,23 @@ impl Rule for NumberArgOutOfRange {
                 match member.static_property_name() {
                     Some(name @ "toString") => {
                         if !(2.0_f64..=36.0_f64).contains(&value) {
-                            let name = CompactStr::from(name);
-                            ctx.diagnostic(NumberArgOutOfRangeDiagnostic(name, 2, 36, expr.span));
+                            ctx.diagnostic(number_arg_out_of_range_diagnostic(
+                                name, 2, 36, expr.span,
+                            ));
                         }
                     }
                     Some(name @ ("toFixed" | "toExponential")) => {
                         if !(0.0_f64..=20.0_f64).contains(&value) {
-                            let name = CompactStr::from(name);
-                            ctx.diagnostic(NumberArgOutOfRangeDiagnostic(name, 0, 20, expr.span));
+                            ctx.diagnostic(number_arg_out_of_range_diagnostic(
+                                name, 0, 20, expr.span,
+                            ));
                         }
                     }
                     Some(name @ "toPrecision") => {
                         if !(1.0_f64..=21.0_f64).contains(&value) {
-                            let name = CompactStr::from(name);
-                            ctx.diagnostic(NumberArgOutOfRangeDiagnostic(name, 1, 21, expr.span));
+                            ctx.diagnostic(number_arg_out_of_range_diagnostic(
+                                name, 1, 21, expr.span,
+                            ));
                         }
                     }
                     _ => {}
diff --git a/crates/oxc_linter/src/rules/deepscan/uninvoked_array_callback.rs b/crates/oxc_linter/src/rules/deepscan/uninvoked_array_callback.rs
index e70508d4799d..1e0c0adae426 100644
--- a/crates/oxc_linter/src/rules/deepscan/uninvoked_array_callback.rs
+++ b/crates/oxc_linter/src/rules/deepscan/uninvoked_array_callback.rs
@@ -2,25 +2,26 @@ use oxc_ast::{
     ast::{Argument, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("deepscan(uninvoked-array-callback): Uninvoked array callback")]
-#[diagnostic(
-    severity(warning),
-    help("consider filling the array with `undefined` values using `Array.prototype.fill()`")
-)]
-struct UninvokedArrayCallbackDiagnostic(
-    #[label("this callback will not be invoked")] Span,
-    #[label("because this is an array with only empty slots")] Span,
-);
+fn uninvoked_array_callback_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("deepscan(uninvoked-array-callback): Uninvoked array callback")
+        .with_help(
+            "consider filling the array with `undefined` values using `Array.prototype.fill()`",
+        )
+        .with_labels([
+            LabeledSpan::new_with_span(Some("this callback will not be invoked".into()), span0),
+            LabeledSpan::new_with_span(
+                Some("because this is an array with only empty slots".into()),
+                span1,
+            ),
+        ])
+}
 
 /// `https://deepscan.io/docs/rules/uninvoked-array-callback`
 #[derive(Debug, Default, Clone)]
@@ -44,7 +45,9 @@ declare_oxc_lint!(
 
 impl Rule for UninvokedArrayCallback {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::NewExpression(new_expr) = node.kind() else { return };
+        let AstKind::NewExpression(new_expr) = node.kind() else {
+            return;
+        };
         if !new_expr.callee.is_specific_id("Array") {
             return;
         }
@@ -55,7 +58,9 @@ impl Rule for UninvokedArrayCallback {
             return;
         }
 
-        let Some(member_expr_node) = ctx.nodes().parent_node(node.id()) else { return };
+        let Some(member_expr_node) = ctx.nodes().parent_node(node.id()) else {
+            return;
+        };
 
         let AstKind::MemberExpression(member_expr) = member_expr_node.kind() else {
             return;
@@ -78,7 +83,7 @@ impl Rule for UninvokedArrayCallback {
             MemberExpression::StaticMemberExpression(expr) => expr.property.span,
             MemberExpression::PrivateFieldExpression(expr) => expr.field.span,
         };
-        ctx.diagnostic(UninvokedArrayCallbackDiagnostic(property_span, new_expr.span));
+        ctx.diagnostic(uninvoked_array_callback_diagnostic(property_span, new_expr.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/eslint/array_callback_return/mod.rs b/crates/oxc_linter/src/rules/eslint/array_callback_return/mod.rs
index eafc21d02c4f..095ad73c1ab8 100644
--- a/crates/oxc_linter/src/rules/eslint/array_callback_return/mod.rs
+++ b/crates/oxc_linter/src/rules/eslint/array_callback_return/mod.rs
@@ -1,10 +1,7 @@
 pub mod return_checker;
 
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{CompactStr, GetSpan, Span};
 use phf::phf_set;
@@ -18,21 +15,20 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum ArrayCallbackReturnDiagnostic {
-    #[error("eslint(array-callback-return): Missing return on some path for array method {0:?}")]
-    #[diagnostic(
-        severity(warning),
-        help("Array method {0:?} needs to have valid return on all code paths")
-    )]
-    ExpectReturn(CompactStr, #[label] Span),
+fn expect_return(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(array-callback-return): Missing return on some path for array method {x0:?}"
+    ))
+    .with_help(format!("Array method {x0:?} needs to have valid return on all code paths"))
+    .with_labels([span1.into()])
+}
 
-    #[error("eslint(array-callback-return): Unexpected return for array method {0}")]
-    #[diagnostic(
-        severity(warning),
-        help("Array method {0} expects no useless return from the function")
-    )]
-    ExpectNoReturn(CompactStr, #[label] Span),
+fn expect_no_return(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(array-callback-return): Unexpected return for array method {x0:?}"
+    ))
+    .with_help(format!("Array method {x0:?} expects no useless return from the function"))
+    .with_labels([span1.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -107,24 +103,24 @@ impl Rule for ArrayCallbackReturn {
                 ("forEach", false, _) => (),
                 ("forEach", true, _) => {
                     if return_status.may_return_explicit() {
-                        ctx.diagnostic(ArrayCallbackReturnDiagnostic::ExpectNoReturn(
-                            full_array_method_name(array_method),
+                        ctx.diagnostic(expect_no_return(
+                            &full_array_method_name(array_method),
                             function_body.span,
                         ));
                     }
                 }
                 (_, _, true) => {
                     if !return_status.must_return() {
-                        ctx.diagnostic(ArrayCallbackReturnDiagnostic::ExpectReturn(
-                            full_array_method_name(array_method),
+                        ctx.diagnostic(expect_return(
+                            &full_array_method_name(array_method),
                             function_body.span,
                         ));
                     }
                 }
                 (_, _, false) => {
                     if !return_status.must_return() || return_status.may_return_implicit() {
-                        ctx.diagnostic(ArrayCallbackReturnDiagnostic::ExpectReturn(
-                            full_array_method_name(array_method),
+                        ctx.diagnostic(expect_return(
+                            &full_array_method_name(array_method),
                             function_body.span,
                         ));
                     }
diff --git a/crates/oxc_linter/src/rules/eslint/constructor_super.rs b/crates/oxc_linter/src/rules/eslint/constructor_super.rs
index 9d398b0a5f57..4164c0752b92 100644
--- a/crates/oxc_linter/src/rules/eslint/constructor_super.rs
+++ b/crates/oxc_linter/src/rules/eslint/constructor_super.rs
@@ -1,7 +1,3 @@
-// use oxc_diagnostics::{
-//     miette::{self, Diagnostic},
-//     thiserror::Error,
-// };
 use oxc_macros::declare_oxc_lint;
 // use oxc_span::Span;
 
diff --git a/crates/oxc_linter/src/rules/eslint/default_case_last.rs b/crates/oxc_linter/src/rules/eslint/default_case_last.rs
index a6fce1d0edb9..187c607e6ad5 100644
--- a/crates/oxc_linter/src/rules/eslint/default_case_last.rs
+++ b/crates/oxc_linter/src/rules/eslint/default_case_last.rs
@@ -1,17 +1,20 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(default-case-last): Enforce default clauses in switch statements to be last")]
-#[diagnostic(severity(warning))]
-struct DefaultCaseLastDiagnostic(#[label("Default clause should be the last clause.")] pub Span);
+fn default_case_last_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(default-case-last): Enforce default clauses in switch statements to be last",
+    )
+    .with_labels([LabeledSpan::new_with_span(
+        Some("Default clause should be the last clause.".into()),
+        span0,
+    )])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct DefaultCaseLast;
@@ -55,14 +58,16 @@ declare_oxc_lint!(
 
 impl Rule for DefaultCaseLast {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::SwitchStatement(switch) = node.kind() else { return };
+        let AstKind::SwitchStatement(switch) = node.kind() else {
+            return;
+        };
         let cases = &switch.cases;
         let index_of_default = cases.iter().position(|c| c.test.is_none());
 
         if let Some(index) = index_of_default {
             if index != cases.len() - 1 {
                 let default_clause = &cases[index];
-                ctx.diagnostic(DefaultCaseLastDiagnostic(Span::new(
+                ctx.diagnostic(default_case_last_diagnostic(Span::new(
                     default_clause.span.start,
                     default_clause.span.start + 7,
                 )));
diff --git a/crates/oxc_linter/src/rules/eslint/default_param_last.rs b/crates/oxc_linter/src/rules/eslint/default_param_last.rs
index 529e7d2f67b1..8567ad62a7cc 100644
--- a/crates/oxc_linter/src/rules/eslint/default_param_last.rs
+++ b/crates/oxc_linter/src/rules/eslint/default_param_last.rs
@@ -1,18 +1,17 @@
 use oxc_ast::ast::FormalParameter;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(default-param-last): Default parameters should be last")]
-#[diagnostic(severity(warning), help("Enforce default parameters to be last."))]
-struct DefaultParamLastDiagnostic(#[label] pub Span);
+fn default_param_last_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(default-param-last): Default parameters should be last")
+        .with_help("Enforce default parameters to be last.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct DefaultParamLast;
@@ -61,7 +60,7 @@ fn check_params<'a>(items: &'a [FormalParameter<'a>], ctx: &LintContext<'a>) {
             continue;
         }
         if has_seen_plain_param && param.pattern.kind.is_assignment_pattern() {
-            ctx.diagnostic(DefaultParamLastDiagnostic(param.span));
+            ctx.diagnostic(default_param_last_diagnostic(param.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/eslint/eqeqeq.rs b/crates/oxc_linter/src/rules/eslint/eqeqeq.rs
index 7c576a9a5ae5..524f6491a519 100644
--- a/crates/oxc_linter/src/rules/eslint/eqeqeq.rs
+++ b/crates/oxc_linter/src/rules/eslint/eqeqeq.rs
@@ -2,20 +2,19 @@ use oxc_ast::{
     ast::{BinaryExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{BinaryOperator, UnaryOperator};
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(eqeqeq): Expected {1} and instead saw {0}")]
-#[diagnostic(severity(warning), help("Prefer {1} operator"))]
-struct EqeqeqDiagnostic(&'static str, &'static str, #[label] pub Span);
+fn eqeqeq_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint(eqeqeq): Expected {x1} and instead saw {x0}"))
+        .with_help(format!("Prefer {x1} operator"))
+        .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct Eqeqeq {
@@ -59,7 +58,9 @@ impl Rule for Eqeqeq {
     }
 
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::BinaryExpression(binary_expr) = node.kind() else { return };
+        let AstKind::BinaryExpression(binary_expr) = node.kind() else {
+            return;
+        };
         let is_null = is_null_check(binary_expr);
         let enforce_rule_for_null = matches!(self.null_type, NullType::Always);
         let enforce_inverse_rule_for_null = matches!(self.null_type, NullType::Never);
@@ -70,7 +71,7 @@ impl Rule for Eqeqeq {
                 // There are some uncontrolled cases to auto fix.
                 // In ESlint, `null >= null` will be auto fixed to `null > null` which is also wrong.
                 // So I just report it.
-                ctx.diagnostic(EqeqeqDiagnostic(
+                ctx.diagnostic(eqeqeq_diagnostic(
                     operator,
                     &operator[0..operator.len() - 1],
                     binary_expr.span,
@@ -118,7 +119,7 @@ impl Rule for Eqeqeq {
         // If the comparison is a `typeof` comparison or both sides are literals with the same type, then it's safe to fix.
         if is_type_of_binary_bool || are_literals_and_same_type_bool {
             ctx.diagnostic_with_fix(
-                EqeqeqDiagnostic(operator, preferred_operator, operator_span),
+                eqeqeq_diagnostic(operator, preferred_operator, operator_span),
                 || {
                     let start = binary_expr.left.span().end;
                     let end = binary_expr.right.span().start;
@@ -126,7 +127,7 @@ impl Rule for Eqeqeq {
                 },
             );
         } else {
-            ctx.diagnostic(EqeqeqDiagnostic(operator, preferred_operator, operator_span));
+            ctx.diagnostic(eqeqeq_diagnostic(operator, preferred_operator, operator_span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/eslint/for_direction.rs b/crates/oxc_linter/src/rules/eslint/for_direction.rs
index cf5591f3a2b9..cd16d51390eb 100644
--- a/crates/oxc_linter/src/rules/eslint/for_direction.rs
+++ b/crates/oxc_linter/src/rules/eslint/for_direction.rs
@@ -5,25 +5,19 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, UnaryOperator, UpdateOperator};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint(for-direction): The update clause in this loop moves the variable in the wrong direction"
-)]
-#[diagnostic(severity(warning), help("Use while loop for intended infinite loop"))]
-struct ForDirectionDiagnostic(
-    #[label("This test moves in the wrong direction")] pub Span, /*test clause */
-    #[label("with this update")] pub Span,                       /*update clause */
-);
+fn for_direction_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(for-direction): The update clause in this loop moves the variable in the wrong direction")
+        .with_help("Use while loop for intended infinite loop")
+        .with_labels([LabeledSpan::new_with_span(Some("This test moves in the wrong direction".into()), span0), LabeledSpan::new_with_span(Some("with this update".into()), span1)])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ForDirection;
@@ -56,12 +50,12 @@ impl Rule for ForDirection {
                 };
                 let test_operator = &test.operator;
                 let wrong_direction = match (test_operator, counter_position) {
-                    (BinaryOperator::LessEqualThan | BinaryOperator::LessThan, LEFT) => BACKWARD,
-                    (BinaryOperator::LessEqualThan | BinaryOperator::LessThan, RIGHT) => FORWARD,
-                    (BinaryOperator::GreaterEqualThan | BinaryOperator::GreaterThan, LEFT) => {
+                    (BinaryOperator::LessEqualThan | BinaryOperator::LessThan, RIGHT)
+                    | (BinaryOperator::GreaterEqualThan | BinaryOperator::GreaterThan, LEFT) => {
                         FORWARD
                     }
-                    (BinaryOperator::GreaterEqualThan | BinaryOperator::GreaterThan, RIGHT) => {
+                    (BinaryOperator::LessEqualThan | BinaryOperator::LessThan, LEFT)
+                    | (BinaryOperator::GreaterEqualThan | BinaryOperator::GreaterThan, RIGHT) => {
                         BACKWARD
                     }
                     _ => return,
@@ -70,7 +64,7 @@ impl Rule for ForDirection {
                     let update_direction = get_update_direction(update, counter);
                     if update_direction == wrong_direction {
                         let update_span = get_update_span(update);
-                        ctx.diagnostic(ForDirectionDiagnostic(test.span, update_span));
+                        ctx.diagnostic(for_direction_diagnostic(test.span, update_span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/eslint/getter_return.rs b/crates/oxc_linter/src/rules/eslint/getter_return.rs
index cc09e70b84e9..3d8f7b955f0b 100644
--- a/crates/oxc_linter/src/rules/eslint/getter_return.rs
+++ b/crates/oxc_linter/src/rules/eslint/getter_return.rs
@@ -5,10 +5,8 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{
     pg::neighbors_filtered_by_edge_weight, AssignmentValue, BasicBlockElement, EdgeType, Register,
@@ -17,10 +15,11 @@ use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(getter-return): Expected to always return a value in getter.")]
-#[diagnostic(severity(warning), help("Return a value from all code paths in getter."))]
-struct GetterReturnDiagnostic(#[label] pub Span);
+fn getter_return_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(getter-return): Expected to always return a value in getter.")
+        .with_help("Return a value from all code paths in getter.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct GetterReturn {
@@ -309,7 +308,7 @@ impl GetterReturn {
 
         // If not, flag it as a diagnostic.
         if !definitely_returns_in_all_codepaths {
-            ctx.diagnostic(GetterReturnDiagnostic(span));
+            ctx.diagnostic(getter_return_diagnostic(span));
         }
     }
 }
@@ -326,64 +325,28 @@ fn test() {
     use crate::tester::Tester;
     let pass = vec![
         ("var foo = { get bar(){return true;} };", None),
-        (
-            "var foo = { get bar() {return;} };",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "var foo = { get bar(){return true;} };",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "var foo = { get bar(){if(bar) {return;} return true;} };",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
+        ("var foo = { get bar() {return;} };", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("var foo = { get bar(){return true;} };", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("var foo = { get bar(){if(bar) {return;} return true;} };", Some(serde_json::json!([{ "allowImplicit": true }]))),
         ("class foo { get bar(){return true;} }", None),
         ("class foo { get bar(){if(baz){return true;} else {return false;} } }", None),
         ("class foo { get(){return true;} }", None),
-        (
-            "class foo { get bar(){return true;} }",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
+        ("class foo { get bar(){return true;} }", Some(serde_json::json!([{ "allowImplicit": true }]))),
         ("class foo { get bar(){return;} }", Some(serde_json::json!([{ "allowImplicit": true }]))),
         ("Object.defineProperty(foo, \"bar\", { get: function () {return true;}});", None),
-        (
-            "Object.defineProperty(foo, \"bar\", { get: function () { ~function (){ return true; }();return true;}});",
-            None,
-        ),
+        ("Object.defineProperty(foo, \"bar\", { get: function () { ~function (){ return true; }();return true;}});", None),
         ("Object.defineProperties(foo, { bar: { get: function () {return true;}} });", None),
-        (
-            "Object.defineProperties(foo, { bar: { get: function () { ~function (){ return true; }(); return true;}} });",
-            None,
-        ),
+        ("Object.defineProperties(foo, { bar: { get: function () { ~function (){ return true; }(); return true;}} });", None),
         ("Reflect.defineProperty(foo, \"bar\", { get: function () {return true;}});", None),
-        (
-            "Reflect.defineProperty(foo, \"bar\", { get: function () { ~function (){ return true; }();return true;}});",
-            None,
-        ),
+        ("Reflect.defineProperty(foo, \"bar\", { get: function () { ~function (){ return true; }();return true;}});", None),
         ("Object.create(foo, { bar: { get() {return true;} } });", None),
         ("Object.create(foo, { bar: { get: function () {return true;} } });", None),
         ("Object.create(foo, { bar: { get: () => {return true;} } });", None),
-        (
-            "Object.defineProperty(foo, \"bar\", { get: function () {return true;}});",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "Object.defineProperty(foo, \"bar\", { get: function (){return;}});",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "Object.defineProperties(foo, { bar: { get: function () {return true;}} });",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "Object.defineProperties(foo, { bar: { get: function () {return;}} });",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "Reflect.defineProperty(foo, \"bar\", { get: function () {return true;}});",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
+        ("Object.defineProperty(foo, \"bar\", { get: function () {return true;}});", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("Object.defineProperty(foo, \"bar\", { get: function (){return;}});", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("Object.defineProperties(foo, { bar: { get: function () {return true;}} });", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("Object.defineProperties(foo, { bar: { get: function () {return;}} });", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("Reflect.defineProperty(foo, \"bar\", { get: function () {return true;}});", Some(serde_json::json!([{ "allowImplicit": true }]))),
         ("var get = function(){};", None),
         ("var get = function(){ return true; };", None),
         ("var foo = { bar(){} };", None),
@@ -399,7 +362,8 @@ fn test() {
         ("foo.create(null, { bar: { get() {} } });", None),
         ("var foo = { get willThrowSoValid() { throw MyException() } };", None),
         ("export abstract class Foo { protected abstract get foobar(): number; }", None),
-        ("class T {
+        (
+            "class T {
             theme: number;
             get type(): number {
                 switch (theme) {
@@ -409,8 +373,11 @@ fn test() {
                  }
                  throw new Error('test')
             }
-        }", None),
-        ("class T {
+        }",
+            None,
+        ),
+        (
+            "class T {
             theme: number;
             get type(): number {
                 switch (theme) {
@@ -419,11 +386,17 @@ fn test() {
                     default: return 3;
                  }
             }
-        }", None),
-        ("const originalClearTimeout = targetWindow.clearTimeout;
+        }",
+            None,
+        ),
+        (
+            "const originalClearTimeout = targetWindow.clearTimeout;
         Object.defineProperty(targetWindow, 'vscodeOriginalClearTimeout', { get: () => originalClearTimeout });
-        ", None),
-        ("class T {
+        ",
+            None,
+        ),
+        (
+            "class T {
             get width(): number | undefined {
                 const val = undefined
                 if (!val) {
@@ -432,8 +405,10 @@ fn test() {
 
                 return val * val;
             }
-        }", None),
-        ("function fn(): void { console.log('test') }", None)
+        }",
+            None,
+        ),
+        ("function fn(): void { console.log('test') }", None),
     ];
 
     let fail = vec![
@@ -443,70 +418,34 @@ fn test() {
         ("var foo = { get bar() { ~function () {return true;}} };", None),
         ("var foo = { get bar() { return; } };", None),
         ("var foo = { get bar() {} };", Some(serde_json::json!([{ "allowImplicit": true }]))),
-        (
-            "var foo = { get bar() {if (baz) {return;}} };",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
+        ("var foo = { get bar() {if (baz) {return;}} };", Some(serde_json::json!([{ "allowImplicit": true }]))),
         ("class foo { get bar(){} }", None),
         ("var foo = class {\n  static get\nbar(){} }", None),
         ("class foo { get bar(){ if (baz) { return true; }}}", None),
         ("class foo { get bar(){ ~function () { return true; }()}}", None),
         ("class foo { get bar(){} }", Some(serde_json::json!([{ "allowImplicit": true }]))),
-        (
-            "class foo { get bar(){if (baz) {return true;} } }",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
+        ("class foo { get bar(){if (baz) {return true;} } }", Some(serde_json::json!([{ "allowImplicit": true }]))),
         ("Object.defineProperty(foo, 'bar', { get: function (){}});", None),
         ("Object.defineProperty(foo, 'bar', { get: function getfoo (){}});", None),
         ("Object.defineProperty(foo, 'bar', { get(){} });", None),
         ("Object.defineProperty(foo, 'bar', { get: () => {}});", None),
         ("Object.defineProperty(foo, \"bar\", { get: function (){if(bar) {return true;}}});", None),
-        (
-            "Object.defineProperty(foo, \"bar\", { get: function (){ ~function () { return true; }()}});",
-            None,
-        ),
+        ("Object.defineProperty(foo, \"bar\", { get: function (){ ~function () { return true; }()}});", None),
         ("Reflect.defineProperty(foo, 'bar', { get: function (){}});", None),
         ("Object.create(foo, { bar: { get: function() {} } })", None),
         ("Object.create(foo, { bar: { get() {} } })", None),
         ("Object.create(foo, { bar: { get: () => {} } })", None),
-        (
-            "Object.defineProperties(foo, { bar: { get: function () {}} });",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "Object.defineProperties(foo, { bar: { get: function (){if(bar) {return true;}}}});",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "Object.defineProperties(foo, { bar: { get: function () {~function () { return true; }()}} });",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "Object.defineProperty(foo, \"bar\", { get: function (){}});",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "Object.create(foo, { bar: { get: function (){} } });",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "Reflect.defineProperty(foo, \"bar\", { get: function (){}});",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
+        ("Object.defineProperties(foo, { bar: { get: function () {}} });", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("Object.defineProperties(foo, { bar: { get: function (){if(bar) {return true;}}}});", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("Object.defineProperties(foo, { bar: { get: function () {~function () { return true; }()}} });", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("Object.defineProperty(foo, \"bar\", { get: function (){}});", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("Object.create(foo, { bar: { get: function (){} } });", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("Reflect.defineProperty(foo, \"bar\", { get: function (){}});", Some(serde_json::json!([{ "allowImplicit": true }]))),
         ("Object?.defineProperty(foo, 'bar', { get: function (){} });", None),
         ("(Object?.defineProperty)(foo, 'bar', { get: function (){} });", None),
-        (
-            "Object?.defineProperty(foo, 'bar', { get: function (){} });",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "(Object?.defineProperty)(foo, 'bar', { get: function (){} });",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
-        (
-            "(Object?.create)(foo, { bar: { get: function (){} } });",
-            Some(serde_json::json!([{ "allowImplicit": true }])),
-        ),
+        ("Object?.defineProperty(foo, 'bar', { get: function (){} });", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("(Object?.defineProperty)(foo, 'bar', { get: function (){} });", Some(serde_json::json!([{ "allowImplicit": true }]))),
+        ("(Object?.create)(foo, { bar: { get: function (){} } });", Some(serde_json::json!([{ "allowImplicit": true }]))),
     ];
 
     Tester::new(GetterReturn::NAME, pass, fail).test_and_snapshot();
diff --git a/crates/oxc_linter/src/rules/eslint/guard_for_in.rs b/crates/oxc_linter/src/rules/eslint/guard_for_in.rs
index 34ddcf2fceb9..82fb435a3cf5 100644
--- a/crates/oxc_linter/src/rules/eslint/guard_for_in.rs
+++ b/crates/oxc_linter/src/rules/eslint/guard_for_in.rs
@@ -1,18 +1,17 @@
 use oxc_ast::ast::Statement;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(guard-for-in): Require `for-in` loops to include an `if` statement")]
-#[diagnostic(severity(warning), help("The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype."))]
-struct GuardForInDiagnostic(#[label] pub Span);
+fn guard_for_in_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(guard-for-in): Require `for-in` loops to include an `if` statement")
+        .with_help("The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct GuardForIn;
@@ -66,7 +65,7 @@ impl Rule for GuardForIn {
                 }
                 _ => {}
             }
-            ctx.diagnostic(GuardForInDiagnostic(Span::new(
+            ctx.diagnostic(guard_for_in_diagnostic(Span::new(
                 for_in_statement.span.start,
                 for_in_statement.right.span().end + 1,
             )));
diff --git a/crates/oxc_linter/src/rules/eslint/max_lines.rs b/crates/oxc_linter/src/rules/eslint/max_lines.rs
index 37fed1696b34..6aec92d03cbf 100644
--- a/crates/oxc_linter/src/rules/eslint/max_lines.rs
+++ b/crates/oxc_linter/src/rules/eslint/max_lines.rs
@@ -1,18 +1,17 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use serde_json::Value;
 
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(max-lines): {0:?}")]
-#[diagnostic(severity(warning), help("Reduce the number of lines in this file"))]
-struct MaxLinesDiagnostic(CompactStr, #[label] Span);
+fn max_lines_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint(max-lines): {x0:?}"))
+        .with_help("Reduce the number of lines in this file")
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct MaxLines(Box<MaxLinesConfig>);
@@ -122,10 +121,10 @@ impl Rule for MaxLines {
         };
 
         if lines_in_file.saturating_sub(blank_lines).saturating_sub(comment_lines) > self.max {
-            let error = CompactStr::from(format!(
+            let error = format!(
                 "File has too many lines ({}). Maximum allowed is {}.",
                 lines_in_file, self.max,
-            ));
+            );
 
             let start = ctx
                 .source_text()
@@ -133,8 +132,8 @@ impl Rule for MaxLines {
                 .take(self.max)
                 .map(|line| line.chars().count() + 1) // padding 1 each line for '\n'
                 .sum::<usize>();
-            ctx.diagnostic(MaxLinesDiagnostic(
-                error,
+            ctx.diagnostic(max_lines_diagnostic(
+                &error,
                 Span::new(
                     u32::try_from(start).unwrap_or(u32::MIN),
                     u32::try_from(ctx.source_text().len()).unwrap_or(u32::MAX),
@@ -189,18 +188,18 @@ fn test() {
         ),
         (
             "var x;
-			
-				
-				  
+
+
+
 			var y;",
             Some(serde_json::json!([{ "max": 2, "skipBlankLines": true }])),
         ),
         (
             "//a single line comment
 			var xy;
-			 
+
 			var xy;
-			 
+
 			 /* a multiline
 			 really really
 			 long comment*/",
@@ -217,18 +216,18 @@ fn test() {
         ("//a single line comment\nvar xy;\nvar xy;", Some(serde_json::json!([2]))),
         (
             "var x;
-			
-			
-			
+
+
+
 			var y;",
             Some(serde_json::json!([{ "max": 2 }])),
         ),
         (
             "//a single line comment
 			var xy;
-			 
+
 			var xy;
-			 
+
 			 /* a multiline
 			 really really
 			 long comment*/",
@@ -250,9 +249,9 @@ fn test() {
         (
             "//a single line comment
 			var xy;
-			 
+
 			var xy;
-			 
+
 			 /* a multiline
 			 really really
 			 long comment*/",
@@ -283,7 +282,7 @@ fn test() {
         ),
         (
             "A
-			
+
 			",
             Some(serde_json::json!([{ "max": 1 }])),
         ),
@@ -310,7 +309,7 @@ fn test() {
         ),
         (
             "
-			
+
 			var a = 'a',
 			c,
 			x;
@@ -322,7 +321,7 @@ fn test() {
 			var x
 			var c;
 			console.log
-			// some block 
+			// some block
 			// comments",
             Some(serde_json::json!([{ "max": 2, "skipComments": true }])),
         ),
@@ -348,37 +347,37 @@ fn test() {
 			var x
 			var c;
 			console.log
-			/** block 
-			
+			/** block
+
 			 comments */",
             Some(serde_json::json!([{ "max": 2, "skipComments": true }])),
         ),
         (
             "var a = 'a';
-			
-			
+
+
 			// comment",
             Some(serde_json::json!([{ "max": 2, "skipComments": true }])),
         ),
         (
             "var a = 'a';
 			var x
-			
-			
+
+
 			var c;
 			console.log
-			
+
 			",
             Some(serde_json::json!([{ "max": 2, "skipBlankLines": true }])),
         ),
         (
             "var a = 'a';
-			
-			
+
+
 			var x
 			var c;
 			console.log
-			
+
 			",
             Some(serde_json::json!([{ "max": 2, "skipBlankLines": true }])),
         ),
@@ -406,14 +405,14 @@ fn test() {
         (
             "
 			var x = '';
-			
+
 			// comment
-			
+
 			var b = '',
 			c,
 			d,
 			e
-			
+
 			// comment",
             Some(serde_json::json!([{ "max": 2, "skipComments": true, "skipBlankLines": true }])),
         ),
diff --git a/crates/oxc_linter/src/rules/eslint/max_params.rs b/crates/oxc_linter/src/rules/eslint/max_params.rs
index 0993a4898a4f..4bda36d5ac06 100644
--- a/crates/oxc_linter/src/rules/eslint/max_params.rs
+++ b/crates/oxc_linter/src/rules/eslint/max_params.rs
@@ -1,21 +1,19 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 use serde_json::Value;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(max-params): {0:?}")]
-#[diagnostic(
-    severity(warning),
-    help("This rule enforces a maximum number of parameters allowed in function definitions.")
-)]
-struct MaxParamsDiagnostic(CompactStr, #[label] pub Span);
+fn max_params_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint(max-params): {x0:?}"))
+        .with_help(
+            "This rule enforces a maximum number of parameters allowed in function definitions.",
+        )
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct MaxParams(Box<MaxParamsConfig>);
@@ -91,18 +89,22 @@ impl Rule for MaxParams {
                             function.params.items.len(),
                             self.max
                         );
-                        let error = CompactStr::from(error_msg);
                         let span = function.params.span;
-                        ctx.diagnostic(MaxParamsDiagnostic(error, Span::new(span.start, span.end)));
+                        ctx.diagnostic(max_params_diagnostic(
+                            &error_msg,
+                            Span::new(span.start, span.end),
+                        ));
                     } else {
                         let error_msg = format!(
                             "Function has too many parameters ({}). Maximum allowed is {}.",
                             function.params.items.len(),
                             self.max
                         );
-                        let error = CompactStr::from(error_msg);
                         let span = function.params.span;
-                        ctx.diagnostic(MaxParamsDiagnostic(error, Span::new(span.start, span.end)));
+                        ctx.diagnostic(max_params_diagnostic(
+                            &error_msg,
+                            Span::new(span.start, span.end),
+                        ));
                     }
                 }
             }
@@ -113,9 +115,11 @@ impl Rule for MaxParams {
                         function.params.items.len(),
                         self.max
                     );
-                    let error = CompactStr::from(error_msg);
                     let span = function.params.span;
-                    ctx.diagnostic(MaxParamsDiagnostic(error, Span::new(span.start, span.end)));
+                    ctx.diagnostic(max_params_diagnostic(
+                        &error_msg,
+                        Span::new(span.start, span.end),
+                    ));
                 }
             }
             _ => {}
diff --git a/crates/oxc_linter/src/rules/eslint/no_array_constructor.rs b/crates/oxc_linter/src/rules/eslint/no_array_constructor.rs
index f9e331aa6000..62f87fa3d90e 100644
--- a/crates/oxc_linter/src/rules/eslint/no_array_constructor.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_array_constructor.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-array-constructor): Disallow `Array` constructors")]
-#[diagnostic(severity(warning), help("Use array literal instead"))]
-struct NoArrayConstructorDiagnostic(#[label] pub Span);
+fn no_array_constructor_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-array-constructor): Disallow `Array` constructors")
+        .with_help("Use array literal instead")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoArrayConstructor;
@@ -58,7 +57,7 @@ impl Rule for NoArrayConstructor {
             && type_parameters.is_none()
             && !optional
         {
-            ctx.diagnostic(NoArrayConstructorDiagnostic(span));
+            ctx.diagnostic(no_array_constructor_diagnostic(span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_async_promise_executor.rs b/crates/oxc_linter/src/rules/eslint/no_async_promise_executor.rs
index 7ea55526f245..1234f8e086a2 100644
--- a/crates/oxc_linter/src/rules/eslint/no_async_promise_executor.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_async_promise_executor.rs
@@ -2,19 +2,19 @@ use oxc_ast::{
     ast::{Argument, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-async-promise-executor): Promise executor functions should not be `async`.")]
-#[diagnostic(severity(warning))]
-struct NoAsyncPromiseExecutorDiagnostic(#[label] pub Span);
+fn no_async_promise_executor_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(no-async-promise-executor): Promise executor functions should not be `async`.",
+    )
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAsyncPromiseExecutor;
@@ -51,7 +51,9 @@ declare_oxc_lint!(
 
 impl Rule for NoAsyncPromiseExecutor {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::NewExpression(new_expression) = node.kind() else { return };
+        let AstKind::NewExpression(new_expression) = node.kind() else {
+            return;
+        };
         if !new_expression.callee.is_specific_id("Promise") {
             return;
         }
@@ -68,7 +70,7 @@ impl Rule for NoAsyncPromiseExecutor {
 
         span.end = span.start + 5;
 
-        ctx.diagnostic(NoAsyncPromiseExecutorDiagnostic(span));
+        ctx.diagnostic(no_async_promise_executor_diagnostic(span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/eslint/no_await_in_loop.rs b/crates/oxc_linter/src/rules/eslint/no_await_in_loop.rs
index a573a29ac991..b51c49527169 100644
--- a/crates/oxc_linter/src/rules/eslint/no_await_in_loop.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_await_in_loop.rs
@@ -2,19 +2,17 @@ use oxc_ast::{
     ast::{Expression, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-await-in-loop): Unexpected `await` inside a loop.")]
-#[diagnostic(severity(warning))]
-struct NoAwaitInLoopDiagnostic(#[label] pub Span);
+fn no_await_in_loop_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-await-in-loop): Unexpected `await` inside a loop.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAwaitInLoop;
@@ -84,7 +82,7 @@ impl Rule for NoAwaitInLoop {
         }
 
         if is_in_loop {
-            ctx.diagnostic(NoAwaitInLoopDiagnostic(span));
+            ctx.diagnostic(no_await_in_loop_diagnostic(span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_bitwise.rs b/crates/oxc_linter/src/rules/eslint/no_bitwise.rs
index cf9994138693..198c695b5113 100644
--- a/crates/oxc_linter/src/rules/eslint/no_bitwise.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_bitwise.rs
@@ -1,21 +1,17 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::BinaryOperator;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-bitwise): Unexpected use of {0:?}")]
-#[diagnostic(
-    severity(warning),
-    help("bitwise operators are not allowed, maybe you mistyped `&&` or `||`")
-)]
-struct NoBitwiseDiagnostic(&'static str, #[label] pub Span);
+fn no_bitwise_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint(no-bitwise): Unexpected use of {x0:?}"))
+        .with_help("bitwise operators are not allowed, maybe you mistyped `&&` or `||`")
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoBitwise(Box<NoBitwiseConfig>);
@@ -84,7 +80,7 @@ impl Rule for NoBitwise {
                     && !allowed_operator(&self.allow, op)
                     && !is_int32_hint(self.int32_hint, node)
                 {
-                    ctx.diagnostic(NoBitwiseDiagnostic(op, bin_expr.span));
+                    ctx.diagnostic(no_bitwise_diagnostic(op, bin_expr.span));
                 }
             }
             AstKind::UnaryExpression(unary_expr) => {
@@ -94,7 +90,7 @@ impl Rule for NoBitwise {
                     && !allowed_operator(&self.allow, op)
                     && !is_int32_hint(self.int32_hint, node)
                 {
-                    ctx.diagnostic(NoBitwiseDiagnostic(op, unary_expr.span));
+                    ctx.diagnostic(no_bitwise_diagnostic(op, unary_expr.span));
                 }
             }
             AstKind::AssignmentExpression(assign_expr) => {
@@ -104,7 +100,7 @@ impl Rule for NoBitwise {
                     && !allowed_operator(&self.allow, op)
                     && !is_int32_hint(self.int32_hint, node)
                 {
-                    ctx.diagnostic(NoBitwiseDiagnostic(op, assign_expr.span));
+                    ctx.diagnostic(no_bitwise_diagnostic(op, assign_expr.span));
                 }
             }
             _ => {}
diff --git a/crates/oxc_linter/src/rules/eslint/no_caller.rs b/crates/oxc_linter/src/rules/eslint/no_caller.rs
index 2690bfcccbca..b59a8001c8cc 100644
--- a/crates/oxc_linter/src/rules/eslint/no_caller.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_caller.rs
@@ -1,22 +1,16 @@
 use oxc_ast::{ast::MemberExpression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-caller): Disallow the use of arguments.caller or arguments.callee")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them"
-    )
-)]
-struct NoCallerDiagnostic(#[label] pub Span);
+fn no_caller_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-caller): Disallow the use of arguments.caller or arguments.callee")
+        .with_help("'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoCaller;
@@ -57,7 +51,7 @@ impl Rule for NoCaller {
             if (expr.property.name == "callee" || expr.property.name == "caller")
                 && expr.object.is_specific_id("arguments")
             {
-                ctx.diagnostic(NoCallerDiagnostic(expr.property.span));
+                ctx.diagnostic(no_caller_diagnostic(expr.property.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/eslint/no_case_declarations.rs b/crates/oxc_linter/src/rules/eslint/no_case_declarations.rs
index 9e48ea420ad9..6fbe2ba3fd8b 100644
--- a/crates/oxc_linter/src/rules/eslint/no_case_declarations.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_case_declarations.rs
@@ -2,19 +2,19 @@ use oxc_ast::{
     ast::{Statement, VariableDeclarationKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-case-declarations): Unexpected lexical declaration in case block.")]
-#[diagnostic(severity(warning))]
-struct NoCaseDeclarationsDiagnostic(#[label] pub Span);
+fn no_case_declarations_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(no-case-declarations): Unexpected lexical declaration in case block.",
+    )
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoCaseDeclarations;
@@ -58,12 +58,12 @@ impl Rule for NoCaseDeclarations {
                     Statement::FunctionDeclaration(d) => {
                         let start = d.span.start;
                         let end = start + 8;
-                        ctx.diagnostic(NoCaseDeclarationsDiagnostic(Span::new(start, end)));
+                        ctx.diagnostic(no_case_declarations_diagnostic(Span::new(start, end)));
                     }
                     Statement::ClassDeclaration(d) => {
                         let start = d.span.start;
                         let end = start + 5;
-                        ctx.diagnostic(NoCaseDeclarationsDiagnostic(Span::new(start, end)));
+                        ctx.diagnostic(no_case_declarations_diagnostic(Span::new(start, end)));
                     }
                     Statement::VariableDeclaration(var) if var.kind.is_lexical() => {
                         let start = var.span.start;
@@ -73,7 +73,7 @@ impl Rule for NoCaseDeclarations {
                             VariableDeclarationKind::Let => 3,
                         };
                         let end = start + end;
-                        ctx.diagnostic(NoCaseDeclarationsDiagnostic(Span::new(start, end)));
+                        ctx.diagnostic(no_case_declarations_diagnostic(Span::new(start, end)));
                     }
                     _ => {}
                 };
diff --git a/crates/oxc_linter/src/rules/eslint/no_class_assign.rs b/crates/oxc_linter/src/rules/eslint/no_class_assign.rs
index 0fd482fc7349..89d22c1eff81 100644
--- a/crates/oxc_linter/src/rules/eslint/no_class_assign.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_class_assign.rs
@@ -1,21 +1,20 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::SymbolId;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-class-assign): Unexpected re-assignment of class {0}")]
-#[diagnostic(severity(warning))]
-struct NoClassAssignDiagnostic(
-    CompactStr,
-    #[label("{0} is declared as class here")] pub Span,
-    #[label("{0} is re-assigned here")] pub Span,
-);
+fn no_class_assign_diagnostic(x0: &str, span1: Span, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(no-class-assign): Unexpected re-assignment of class {x0}"
+    ))
+    .with_labels([
+        LabeledSpan::new_with_span(Some(format!("{x0} is declared as class here")), span1),
+        LabeledSpan::new_with_span(Some(format!("{x0} is re-assigned here")), span2),
+    ])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoClassAssign;
@@ -44,8 +43,8 @@ impl Rule for NoClassAssign {
         if symbol_table.get_flag(symbol_id).is_class() {
             for reference in symbol_table.get_resolved_references(symbol_id) {
                 if reference.is_write() {
-                    ctx.diagnostic(NoClassAssignDiagnostic(
-                        symbol_table.get_name(symbol_id).into(),
+                    ctx.diagnostic(no_class_assign_diagnostic(
+                        symbol_table.get_name(symbol_id),
                         symbol_table.get_span(symbol_id),
                         reference.span(),
                     ));
diff --git a/crates/oxc_linter/src/rules/eslint/no_compare_neg_zero.rs b/crates/oxc_linter/src/rules/eslint/no_compare_neg_zero.rs
index 9184f4f4f0ed..ea0d75bba8fc 100644
--- a/crates/oxc_linter/src/rules/eslint/no_compare_neg_zero.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_compare_neg_zero.rs
@@ -1,21 +1,19 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::{BinaryOperator, UnaryOperator};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-compare-neg-zero): Do not use the {0} operator to compare against -0.")]
-#[diagnostic(
-    severity(warning),
-    help("Use Object.is(x, -0) to test equality with -0 and use 0 for other cases")
-)]
-struct NoCompareNegZeroDiagnostic(&'static str, #[label] pub Span);
+fn no_compare_neg_zero_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(no-compare-neg-zero): Do not use the {x0} operator to compare against -0."
+    ))
+    .with_help("Use Object.is(x, -0) to test equality with -0 and use 0 for other cases")
+    .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoCompareNegZero;
@@ -45,7 +43,7 @@ impl Rule for NoCompareNegZero {
         if Self::should_check(expr.operator) {
             let op = expr.operator.as_str();
             if is_neg_zero(&expr.left) || is_neg_zero(&expr.right) {
-                ctx.diagnostic(NoCompareNegZeroDiagnostic(op, expr.span));
+                ctx.diagnostic(no_compare_neg_zero_diagnostic(op, expr.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/eslint/no_cond_assign.rs b/crates/oxc_linter/src/rules/eslint/no_cond_assign.rs
index 1252376ae80b..fa22e7d7dc63 100644
--- a/crates/oxc_linter/src/rules/eslint/no_cond_assign.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_cond_assign.rs
@@ -2,19 +2,20 @@ use oxc_ast::{
     ast::{AssignmentExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-cond-assign): Expected a conditional expression and instead saw an assignment")]
-#[diagnostic(severity(warning), help("Consider wrapping the assignment in additional parentheses"))]
-struct NoCondAssignDiagnostic(#[label] pub Span);
+fn no_cond_assign_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(no-cond-assign): Expected a conditional expression and instead saw an assignment",
+    )
+    .with_help("Consider wrapping the assignment in additional parentheses")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoCondAssign {
@@ -99,7 +100,7 @@ impl NoCondAssign {
         operator_span.start += start;
         operator_span.end = operator_span.start + expr.operator.as_str().len() as u32;
 
-        ctx.diagnostic(NoCondAssignDiagnostic(operator_span));
+        ctx.diagnostic(no_cond_assign_diagnostic(operator_span));
     }
     fn check_expression(&self, ctx: &LintContext<'_>, expr: &Expression<'_>) {
         let mut expr = expr;
diff --git a/crates/oxc_linter/src/rules/eslint/no_console.rs b/crates/oxc_linter/src/rules/eslint/no_console.rs
index 8e7196d57844..409caaaea956 100644
--- a/crates/oxc_linter/src/rules/eslint/no_console.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_console.rs
@@ -1,17 +1,15 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-console): Unexpected console statement.")]
-#[diagnostic(severity(warning))]
-struct NoConsoleDiagnostic(#[label] pub Span);
+fn no_console_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-console): Unexpected console statement.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoConsole(Box<NoConsoleConfig>);
@@ -83,7 +81,7 @@ impl Rule for NoConsole {
                             .any(|s| mem.static_property_name().is_some_and(|f| f == s))
                     {
                         if let Some(mem) = mem.static_property_info() {
-                            ctx.diagnostic(NoConsoleDiagnostic(mem.0));
+                            ctx.diagnostic(no_console_diagnostic(mem.0));
                         }
                     }
                 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_const_assign.rs b/crates/oxc_linter/src/rules/eslint/no_const_assign.rs
index d9ac98549c0c..a18ef557d382 100644
--- a/crates/oxc_linter/src/rules/eslint/no_const_assign.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_const_assign.rs
@@ -1,21 +1,20 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::SymbolId;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-const-assign): Unexpected re-assignment of const variable {0}")]
-#[diagnostic(severity(warning))]
-struct NoConstAssignDiagnostic(
-    CompactStr,
-    #[label("{0} is declared here as const")] pub Span,
-    #[label("{0} is re-assigned here")] pub Span,
-);
+fn no_const_assign_diagnostic(x0: &str, span1: Span, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(no-const-assign): Unexpected re-assignment of const variable {x0}"
+    ))
+    .with_labels([
+        LabeledSpan::new_with_span(Some(format!("{x0} is declared here as const")), span1),
+        LabeledSpan::new_with_span(Some(format!("{x0} is re-assigned here")), span2),
+    ])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoConstAssign;
@@ -43,8 +42,8 @@ impl Rule for NoConstAssign {
         if symbol_table.get_flag(symbol_id).is_const_variable() {
             for reference in symbol_table.get_resolved_references(symbol_id) {
                 if reference.is_write() {
-                    ctx.diagnostic(NoConstAssignDiagnostic(
-                        symbol_table.get_name(symbol_id).into(),
+                    ctx.diagnostic(no_const_assign_diagnostic(
+                        symbol_table.get_name(symbol_id),
                         symbol_table.get_span(symbol_id),
                         reference.span(),
                     ));
diff --git a/crates/oxc_linter/src/rules/eslint/no_constant_binary_expression.rs b/crates/oxc_linter/src/rules/eslint/no_constant_binary_expression.rs
index 8df5e757cf3b..f01d39909e4f 100644
--- a/crates/oxc_linter/src/rules/eslint/no_constant_binary_expression.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_constant_binary_expression.rs
@@ -1,9 +1,7 @@
 #[allow(clippy::wildcard_imports)]
 use oxc_ast::{ast::*, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, LogicalOperator, UnaryOperator};
@@ -51,39 +49,38 @@ declare_oxc_lint!(
     correctness
 );
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint(no-constant-binary-expression): Unexpected constant {0:?} on the left-hand side of a {1:?} expression"
-)]
-#[diagnostic(
-    severity(warning),
-    help("This expression always evaluates to the constant on the left-hand side")
-)]
-struct ConstantShortCircuit(&'static str, &'static str, #[label] Span);
+fn constant_short_circuit(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint(no-constant-binary-expression): Unexpected constant {x0:?} on the left-hand side of a {x1:?} expression"))
+        .with_help("This expression always evaluates to the constant on the left-hand side")
+        .with_labels([span2.into()])
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-constant-binary-expression): Unexpected constant binary expression")]
-#[diagnostic(severity(warning), help("This compares constantly with the {0}-hand side of the {1}"))]
-struct ConstantBinaryOperand(&'static str, &'static str, #[label] Span);
+fn constant_binary_operand(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(no-constant-binary-expression): Unexpected constant binary expression",
+    )
+    .with_help(format!("This compares constantly with the {x0}-hand side of the {x1}"))
+    .with_labels([span2.into()])
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-constant-binary-expression): Unexpected comparison to newly constructed object")]
-#[diagnostic(severity(warning), help("These two values can never be equal"))]
-struct ConstantAlwaysNew(#[label] Span);
+fn constant_always_new(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(no-constant-binary-expression): Unexpected comparison to newly constructed object",
+    )
+    .with_help("These two values can never be equal")
+    .with_labels([span0.into()])
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint(no-constant-binary-expression): Unexpected comparison of two newly constructed objects"
-)]
-#[diagnostic(severity(warning), help("These two values can never be equal"))]
-struct ConstantBothAlwaysNew(#[label] Span);
+fn constant_both_always_new(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-constant-binary-expression): Unexpected comparison of two newly constructed objects").with_help("These two values can never be equal").with_labels([span0.into()])
+}
 
 impl Rule for NoConstantBinaryExpression {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         match node.kind() {
             AstKind::LogicalExpression(expr) => match expr.operator {
                 LogicalOperator::Or | LogicalOperator::And if expr.left.is_constant(true, ctx) => {
-                    ctx.diagnostic(ConstantShortCircuit(
+                    ctx.diagnostic(constant_short_circuit(
                         "truthiness",
                         expr.operator.as_str(),
                         expr.span,
@@ -92,7 +89,7 @@ impl Rule for NoConstantBinaryExpression {
                 LogicalOperator::Coalesce
                     if Self::has_constant_nullishness(&expr.left, false, ctx) =>
                 {
-                    ctx.diagnostic(ConstantShortCircuit(
+                    ctx.diagnostic(constant_short_circuit(
                         "nullishness",
                         expr.operator.as_str(),
                         expr.span,
@@ -112,12 +109,12 @@ impl Rule for NoConstantBinaryExpression {
                     Self::find_binary_expression_constant_operand(right, left, operator, ctx);
 
                 if right_constant_operand.is_some() {
-                    ctx.diagnostic(ConstantBinaryOperand("left", operator.as_str(), expr.span));
+                    ctx.diagnostic(constant_binary_operand("left", operator.as_str(), expr.span));
                     return;
                 }
 
                 if left_constant_operand.is_some() {
-                    ctx.diagnostic(ConstantBinaryOperand("right", operator.as_str(), expr.span));
+                    ctx.diagnostic(constant_binary_operand("right", operator.as_str(), expr.span));
                     return;
                 }
 
@@ -126,7 +123,7 @@ impl Rule for NoConstantBinaryExpression {
                     BinaryOperator::StrictEquality | BinaryOperator::StrictInequality
                 ) && (Self::is_always_new(left, ctx) || Self::is_always_new(right, ctx))
                 {
-                    ctx.diagnostic(ConstantAlwaysNew(expr.span));
+                    ctx.diagnostic(constant_always_new(expr.span));
                     return;
                 }
 
@@ -134,7 +131,7 @@ impl Rule for NoConstantBinaryExpression {
                     && Self::is_always_new(left, ctx)
                     && Self::is_always_new(right, ctx)
                 {
-                    ctx.diagnostic(ConstantBothAlwaysNew(expr.span));
+                    ctx.diagnostic(constant_both_always_new(expr.span));
                 }
             }
             _ => {}
diff --git a/crates/oxc_linter/src/rules/eslint/no_constant_condition.rs b/crates/oxc_linter/src/rules/eslint/no_constant_condition.rs
index 2b668917a3ec..dc2a3a7538b7 100644
--- a/crates/oxc_linter/src/rules/eslint/no_constant_condition.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_constant_condition.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{ast_util::IsConstant, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-constant-condition): Unexpected constant condition")]
-#[diagnostic(severity(warning), help("Constant expression as a test condition is not allowed"))]
-struct NoConstantConditionDiagnostic(#[label] pub Span);
+fn no_constant_condition_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-constant-condition): Unexpected constant condition")
+        .with_help("Constant expression as a test condition is not allowed")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoConstantCondition {
@@ -54,12 +53,12 @@ impl Rule for NoConstantCondition {
         match node.kind() {
             AstKind::IfStatement(if_stmt) => {
                 if if_stmt.test.is_constant(true, ctx) {
-                    ctx.diagnostic(NoConstantConditionDiagnostic(if_stmt.test.span()));
+                    ctx.diagnostic(no_constant_condition_diagnostic(if_stmt.test.span()));
                 }
             }
             AstKind::ConditionalExpression(condition_expr) => {
                 if condition_expr.test.is_constant(true, ctx) {
-                    ctx.diagnostic(NoConstantConditionDiagnostic(condition_expr.test.span()));
+                    ctx.diagnostic(no_constant_condition_diagnostic(condition_expr.test.span()));
                 }
             }
             _ => {}
diff --git a/crates/oxc_linter/src/rules/eslint/no_continue.rs b/crates/oxc_linter/src/rules/eslint/no_continue.rs
index 9dc83e1098c4..00aafdc1639a 100644
--- a/crates/oxc_linter/src/rules/eslint/no_continue.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_continue.rs
@@ -1,16 +1,15 @@
 use crate::{context::LintContext, rule::Rule, AstNode};
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-continue): Unexpected use of `continue` statement.")]
-#[diagnostic(severity(warning), help("Do not use the `continue` statement."))]
-struct NoContinueDiagnostic(#[label] pub Span);
+fn no_continue_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-continue): Unexpected use of `continue` statement.")
+        .with_help("Do not use the `continue` statement.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoContinue;
@@ -42,7 +41,7 @@ declare_oxc_lint!(
 impl Rule for NoContinue {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::ContinueStatement(continue_statement) = node.kind() {
-            ctx.diagnostic(NoContinueDiagnostic(Span::new(
+            ctx.diagnostic(no_continue_diagnostic(Span::new(
                 continue_statement.span.start,
                 continue_statement.span.start + 8,
             )));
@@ -61,9 +60,9 @@ fn test() {
 
     let fail = vec![
         "var sum = 0, i; for(i = 0; i < 10; i++){ if(i <= 5) { continue; } sum += i; }",
-"var sum = 0, i; myLabel: for(i = 0; i < 10; i++){ if(i <= 5) { continue myLabel; } sum += i; }",
-"var sum = 0, i = 0; while(i < 10) { if(i <= 5) { i++; continue; } sum += i; i++; }",
-"var sum = 0, i = 0; myLabel: while(i < 10) { if(i <= 5) { i++; continue myLabel; } sum += i; i++; }"
+        "var sum = 0, i; myLabel: for(i = 0; i < 10; i++){ if(i <= 5) { continue myLabel; } sum += i; }",
+        "var sum = 0, i = 0; while(i < 10) { if(i <= 5) { i++; continue; } sum += i; i++; }",
+        "var sum = 0, i = 0; myLabel: while(i < 10) { if(i <= 5) { i++; continue myLabel; } sum += i; i++; }",
     ];
 
     Tester::new(NoContinue::NAME, pass, fail).test_and_snapshot();
diff --git a/crates/oxc_linter/src/rules/eslint/no_control_regex.rs b/crates/oxc_linter/src/rules/eslint/no_control_regex.rs
index 0bc45bc18884..cd5a259f1269 100644
--- a/crates/oxc_linter/src/rules/eslint/no_control_regex.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_control_regex.rs
@@ -3,23 +3,19 @@ use oxc_ast::{
     ast::{Argument, RegExpFlags},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{Atom, CompactStr, GetSpan, Span};
+use oxc_span::{Atom, GetSpan, Span};
 use regex::{Matches, Regex};
 
 use crate::{ast_util::extract_regex_flags, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-control-regex): Unexpected control character(s)")]
-#[diagnostic(
-    severity(warning),
-    help("Unexpected control character(s) in regular expression: \"{0}\"")
-)]
-struct NoControlRegexDiagnostic(CompactStr, #[label] pub Span);
+fn no_control_regex_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-control-regex): Unexpected control character(s)")
+        .with_help(format!("Unexpected control character(s) in regular expression: \"{x0}\""))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoControlRegex;
@@ -135,7 +131,7 @@ impl Rule for NoControlRegex {
 
             if !violations.is_empty() {
                 let violations = violations.join(", ");
-                context.diagnostic(NoControlRegexDiagnostic(violations.into(), span));
+                context.diagnostic(no_control_regex_diagnostic(&violations, span));
             }
         }
     }
@@ -291,7 +287,6 @@ mod tests {
                 r"let r = new RegExp('\\u000c');",
                 r"let r = new RegExp('\\u000C');",
                 r"let r = new RegExp('\\u001f');",
-
             ],
         )
         .test();
diff --git a/crates/oxc_linter/src/rules/eslint/no_debugger.rs b/crates/oxc_linter/src/rules/eslint/no_debugger.rs
index 6db9c9811a56..a9e2dc435b9f 100644
--- a/crates/oxc_linter/src/rules/eslint/no_debugger.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_debugger.rs
@@ -1,17 +1,15 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-debugger): `debugger` statement is not allowed")]
-#[diagnostic(severity(warning))]
-struct NoDebuggerDiagnostic(#[label] pub Span);
+fn no_debugger_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-debugger): `debugger` statement is not allowed")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDebugger;
@@ -37,7 +35,7 @@ declare_oxc_lint!(
 impl Rule for NoDebugger {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::DebuggerStatement(stmt) = node.kind() {
-            ctx.diagnostic_with_fix(NoDebuggerDiagnostic(stmt.span), || Fix::delete(stmt.span));
+            ctx.diagnostic_with_fix(no_debugger_diagnostic(stmt.span), || Fix::delete(stmt.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_delete_var.rs b/crates/oxc_linter/src/rules/eslint/no_delete_var.rs
index 46e3e31c0d7e..b63198e42d2b 100644
--- a/crates/oxc_linter/src/rules/eslint/no_delete_var.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_delete_var.rs
@@ -1,18 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::UnaryOperator;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-delete-var): variables should not be deleted")]
-#[diagnostic(severity(warning))]
-struct NoDeleteVarDiagnostic(#[label] pub Span);
+fn no_delete_var_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-delete-var): variables should not be deleted")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDeleteVar;
@@ -37,9 +35,11 @@ declare_oxc_lint!(
 
 impl Rule for NoDeleteVar {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::UnaryExpression(expr) = node.kind() else { return };
+        let AstKind::UnaryExpression(expr) = node.kind() else {
+            return;
+        };
         if expr.operator == UnaryOperator::Delete && expr.argument.is_identifier_reference() {
-            ctx.diagnostic(NoDeleteVarDiagnostic(expr.span));
+            ctx.diagnostic(no_delete_var_diagnostic(expr.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_dupe_class_members.rs b/crates/oxc_linter/src/rules/eslint/no_dupe_class_members.rs
index 64044fbc0aa2..fa9831094cad 100644
--- a/crates/oxc_linter/src/rules/eslint/no_dupe_class_members.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_dupe_class_members.rs
@@ -1,26 +1,20 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 use rustc_hash::FxHashMap;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-dupe-class-members): Duplicate class member: {0:?}")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "The last declaration overwrites previous ones, remove one of them or rename if both should be retained"
-    )
-)]
-struct NoDupeClassMembersDiagnostic(
-    CompactStr, /*Class member name */
-    #[label("{0:?} is previously declared here")] pub Span,
-    #[label("{0:?} is re-declared here")] pub Span,
-);
+fn no_dupe_class_members_diagnostic(
+    x0: &str, /*Class member name */
+    span1: Span,
+    span2: Span,
+) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint(no-dupe-class-members): Duplicate class member: {x0:?}"))
+        .with_help("The last declaration overwrites previous ones, remove one of them or rename if both should be retained")
+        .with_labels([LabeledSpan::new_with_span(Some(format!("{x0:?} is previously declared here")), span1), LabeledSpan::new_with_span(Some(format!("{x0:?} is re-declared here")), span2)])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDupeClassMembers;
@@ -60,8 +54,8 @@ impl Rule for NoDupeClassMembers {
                             && prev_element.kind.is_setter_or_getter())
                             || element.kind == prev_element.kind)
                     {
-                        ctx.diagnostic(NoDupeClassMembersDiagnostic(
-                            element.name.clone(),
+                        ctx.diagnostic(no_dupe_class_members_diagnostic(
+                            &element.name,
                             prev_element.span,
                             element.span,
                         ));
diff --git a/crates/oxc_linter/src/rules/eslint/no_dupe_else_if.rs b/crates/oxc_linter/src/rules/eslint/no_dupe_else_if.rs
index 999b82148abd..502b0269d34f 100644
--- a/crates/oxc_linter/src/rules/eslint/no_dupe_else_if.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_dupe_else_if.rs
@@ -2,25 +2,19 @@ use oxc_ast::{
     ast::{Expression, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::LogicalOperator;
 
 use crate::{ast_util::calculate_hash, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-dupe-else-if): duplicate conditions in if-else-if chains")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain"
-    )
-)]
-struct NoDupeElseIfDiagnostic(#[label] pub Span, #[label] pub Span);
+fn no_dupe_else_if_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-dupe-else-if): duplicate conditions in if-else-if chains")
+        .with_help("This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain")
+        .with_labels([span0.into(), span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDupeElseIf;
@@ -55,11 +49,15 @@ impl Rule for NoDupeElseIf {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         // if (a) {} else if (a) {}
         //                ^^ get this if statement
-        let AstKind::IfStatement(if_stmt) = node.kind() else { return };
+        let AstKind::IfStatement(if_stmt) = node.kind() else {
+            return;
+        };
         let Some(AstKind::IfStatement(parent_if_stmt)) = ctx.nodes().parent_kind(node.id()) else {
             return;
         };
-        let Some(Statement::IfStatement(child_if_stmt)) = &parent_if_stmt.alternate else { return };
+        let Some(Statement::IfStatement(child_if_stmt)) = &parent_if_stmt.alternate else {
+            return;
+        };
         if child_if_stmt.span != if_stmt.span {
             return;
         }
@@ -79,7 +77,9 @@ impl Rule for NoDupeElseIf {
 
         let mut current_node = node;
         while let Some(parent_node) = ctx.nodes().parent_node(current_node.id()) {
-            let AstKind::IfStatement(stmt) = parent_node.kind() else { break };
+            let AstKind::IfStatement(stmt) = parent_node.kind() else {
+                break;
+            };
 
             if !stmt
                 .alternate
@@ -109,7 +109,7 @@ impl Rule for NoDupeElseIf {
                 .collect();
 
             if list_to_check.iter().any(Vec::is_empty) {
-                ctx.diagnostic(NoDupeElseIfDiagnostic(if_stmt.test.span(), stmt.test.span()));
+                ctx.diagnostic(no_dupe_else_if_diagnostic(if_stmt.test.span(), stmt.test.span()));
                 break;
             }
         }
diff --git a/crates/oxc_linter/src/rules/eslint/no_dupe_keys.rs b/crates/oxc_linter/src/rules/eslint/no_dupe_keys.rs
index 4b962f1182bf..134ee77ebeb1 100644
--- a/crates/oxc_linter/src/rules/eslint/no_dupe_keys.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_dupe_keys.rs
@@ -2,20 +2,19 @@ use oxc_ast::{
     ast::{ObjectPropertyKind, PropertyKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use rustc_hash::FxHashMap;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-dupe-keys): Disallow duplicate keys in object literals")]
-#[diagnostic(severity(warning), help("Consider removing the duplicated key"))]
-struct NoDupeKeysDiagnostic(#[label] pub Span, #[label] pub Span);
+fn no_dupe_keys_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-dupe-keys): Disallow duplicate keys in object literals")
+        .with_help("Consider removing the duplicated key")
+        .with_labels([span0.into(), span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDupeKeys;
@@ -42,17 +41,23 @@ declare_oxc_lint!(
 
 impl Rule for NoDupeKeys {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::ObjectExpression(obj_expr) = node.kind() else { return };
+        let AstKind::ObjectExpression(obj_expr) = node.kind() else {
+            return;
+        };
         let mut map = FxHashMap::default();
         for prop in &obj_expr.properties {
-            let ObjectPropertyKind::ObjectProperty(prop) = prop else { continue };
-            let Some(name) = prop.key.static_name() else { return };
+            let ObjectPropertyKind::ObjectProperty(prop) = prop else {
+                continue;
+            };
+            let Some(name) = prop.key.static_name() else {
+                return;
+            };
             if let Some((prev_kind, prev_span)) = map.insert(name, (prop.kind, prop.key.span())) {
                 if prev_kind == PropertyKind::Init
                     || prop.kind == PropertyKind::Init
                     || prev_kind == prop.kind
                 {
-                    ctx.diagnostic(NoDupeKeysDiagnostic(prev_span, prop.key.span()));
+                    ctx.diagnostic(no_dupe_keys_diagnostic(prev_span, prop.key.span()));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/eslint/no_duplicate_case.rs b/crates/oxc_linter/src/rules/eslint/no_duplicate_case.rs
index f47de9cf6259..23b2006ff65a 100644
--- a/crates/oxc_linter/src/rules/eslint/no_duplicate_case.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_duplicate_case.rs
@@ -1,18 +1,17 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use rustc_hash::FxHashMap;
 
 use crate::{ast_util::calculate_hash, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-duplicate-case): Disallow duplicate case labels")]
-#[diagnostic(severity(warning), help("Remove the duplicated case"))]
-struct NoDuplicateCaseDiagnostic(#[label] pub Span, #[label] pub Span);
+fn no_duplicate_case_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-duplicate-case): Disallow duplicate case labels")
+        .with_help("Remove the duplicated case")
+        .with_labels([span0.into(), span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDuplicateCase;
@@ -55,7 +54,7 @@ impl Rule for NoDuplicateCase {
                     let hash = calculate_hash(test);
 
                     if let Some(prev_span) = map.insert(hash, test.span()) {
-                        ctx.diagnostic(NoDuplicateCaseDiagnostic(prev_span, test.span()));
+                        ctx.diagnostic(no_duplicate_case_diagnostic(prev_span, test.span()));
                     }
                 }
             }
@@ -72,100 +71,34 @@ fn test() {
         ("var a = 1; switch (a) {case 1: break; case '1': break; default: break;}", None),
         ("var a = 1; switch (a) {case 1: break; case true: break; default: break;}", None),
         ("var a = 1; switch (a) {default: break;}", None),
-        (
-            "var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p.p.p1: break; case p.p.p2: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, f = function(b) { return b ? { p1: 1 } : { p1: 2 }; }; switch (a) {case f(true).p1: break; case f(true, false).p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(a + 1).p1: break; case f(a + 2).p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(a == 1 ? 2 : 3).p1: break; case f(a === 1 ? 2 : 3).p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, f1 = function() { return { p1: 1 } }, f2 = function() { return { p1: 2 } }; switch (a) {case f1().p1: break; case f2().p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = [1,2]; switch(a.toString()){case ([1,2]).toString():break; case ([1]).toString():break; default:break;}",
-            None,
-        ),
+        ("var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p.p.p1: break; case p.p.p2: break; default: break;}", None),
+        ("var a = 1, f = function(b) { return b ? { p1: 1 } : { p1: 2 }; }; switch (a) {case f(true).p1: break; case f(true, false).p1: break; default: break;}", None),
+        ("var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(a + 1).p1: break; case f(a + 2).p1: break; default: break;}", None),
+        ("var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(a == 1 ? 2 : 3).p1: break; case f(a === 1 ? 2 : 3).p1: break; default: break;}", None),
+        ("var a = 1, f1 = function() { return { p1: 1 } }, f2 = function() { return { p1: 2 } }; switch (a) {case f1().p1: break; case f2().p1: break; default: break;}", None),
+        ("var a = [1,2]; switch(a.toString()){case ([1,2]).toString():break; case ([1]).toString():break; default:break;}", None),
         ("switch(a) { case a: break; } switch(a) { case a: break; }", None),
         ("switch(a) { case toString: break; }", None),
     ];
 
     let fail = vec![
-        (
-            "var a = 1; switch (a) {case 1: break; case 1: break; case 2: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = '1'; switch (a) {case '1': break; case '1': break; case '2': break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, one = 1; switch (a) {case one: break; case one: break; case 2: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p.p.p1: break; case p.p.p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, f = function(b) { return b ? { p1: 1 } : { p1: 2 }; }; switch (a) {case f(true).p1: break; case f(true).p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(a + 1).p1: break; case f(a + 1).p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(a === 1 ? 2 : 3).p1: break; case f(a === 1 ? 2 : 3).p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, f1 = function() { return { p1: 1 } }; switch (a) {case f1().p1: break; case f1().p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = [1, 2]; switch(a.toString()){case ([1, 2]).toString():break; case ([1, 2]).toString():break; default:break;}",
-            None,
-        ),
+        ("var a = 1; switch (a) {case 1: break; case 1: break; case 2: break; default: break;}", None),
+        ("var a = '1'; switch (a) {case '1': break; case '1': break; case '2': break; default: break;}", None),
+        ("var a = 1, one = 1; switch (a) {case one: break; case one: break; case 2: break; default: break;}", None),
+        ("var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p.p.p1: break; case p.p.p1: break; default: break;}", None),
+        ("var a = 1, f = function(b) { return b ? { p1: 1 } : { p1: 2 }; }; switch (a) {case f(true).p1: break; case f(true).p1: break; default: break;}", None),
+        ("var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(a + 1).p1: break; case f(a + 1).p1: break; default: break;}", None),
+        ("var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(a === 1 ? 2 : 3).p1: break; case f(a === 1 ? 2 : 3).p1: break; default: break;}", None),
+        ("var a = 1, f1 = function() { return { p1: 1 } }; switch (a) {case f1().p1: break; case f1().p1: break; default: break;}", None),
+        ("var a = [1, 2]; switch(a.toString()){case ([1, 2]).toString():break; case ([1, 2]).toString():break; default:break;}", None),
         ("switch (a) { case a: case a: }", None),
-        (
-            "switch (a) { case a: break; case b: break; case a: break; case c: break; case a: break; }",
-            None,
-        ),
-        (
-            "var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p.p.p1: break; case p. p // comment\n .p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p .p\n/* comment */\n.p1: break; case p.p.p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p .p\n/* comment */\n.p1: break; case p. p // comment\n .p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p.p.p1: break; case p. p // comment\n .p1: break; case p .p\n/* comment */\n.p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(a + 1).p1: break; case f(a+1).p1: break; default: break;}",
-            None,
-        ),
-        (
-            "var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(\na + 1 // comment\n).p1: break; case f(a+1)\n.p1: break; default: break;}",
-            None,
-        ),
+        ("switch (a) { case a: break; case b: break; case a: break; case c: break; case a: break; }", None),
+        ("var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p.p.p1: break; case p. p // comment\n .p1: break; default: break;}", None),
+        ("var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p .p\n/* comment */\n.p1: break; case p.p.p1: break; default: break;}", None),
+        ("var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p .p\n/* comment */\n.p1: break; case p. p // comment\n .p1: break; default: break;}", None),
+        ("var a = 1, p = {p: {p1: 1, p2: 1}}; switch (a) {case p.p.p1: break; case p. p // comment\n .p1: break; case p .p\n/* comment */\n.p1: break; default: break;}", None),
+        ("var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(a + 1).p1: break; case f(a+1).p1: break; default: break;}", None),
+        ("var a = 1, f = function(s) { return { p1: s } }; switch (a) {case f(\na + 1 // comment\n).p1: break; case f(a+1)\n.p1: break; default: break;}", None),
     ];
 
     Tester::new(NoDuplicateCase::NAME, pass, fail).test_and_snapshot();
diff --git a/crates/oxc_linter/src/rules/eslint/no_empty.rs b/crates/oxc_linter/src/rules/eslint/no_empty.rs
index f1a34fc7f283..f2be97735692 100644
--- a/crates/oxc_linter/src/rules/eslint/no_empty.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_empty.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-empty): Disallow empty block statements")]
-#[diagnostic(severity(warning), help("Add comment inside empty {0} statement"))]
-struct NoEmptyDiagnostic(&'static str, #[label("Empty {0} statement")] pub Span);
+fn no_empty_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-empty): Disallow empty block statements")
+        .with_help(format!("Add comment inside empty {x0} statement"))
+        .with_labels([LabeledSpan::new_with_span(Some(format!("Empty {x0} statement")), span1)])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoEmpty {
@@ -53,7 +52,7 @@ impl Rule for NoEmpty {
                 if ctx.semantic().trivias().has_comments_between(block.span) {
                     return;
                 }
-                ctx.diagnostic(NoEmptyDiagnostic("block", block.span));
+                ctx.diagnostic(no_empty_diagnostic("block", block.span));
             }
             // The visitor does not visit the `BlockStatement` inside the `CatchClause`.
             // See `Visit::visit_catch_clause`.
@@ -63,7 +62,7 @@ impl Rule for NoEmpty {
                 if ctx.semantic().trivias().has_comments_between(catch_clause.body.span) {
                     return;
                 }
-                ctx.diagnostic(NoEmptyDiagnostic("block", catch_clause.body.span));
+                ctx.diagnostic(no_empty_diagnostic("block", catch_clause.body.span));
             }
             // The visitor does not visit the `BlockStatement` inside the `FinallyClause`.
             // See `Visit::visit_finally_clause`.
@@ -71,10 +70,10 @@ impl Rule for NoEmpty {
                 if ctx.semantic().trivias().has_comments_between(finally_clause.span) {
                     return;
                 }
-                ctx.diagnostic(NoEmptyDiagnostic("block", finally_clause.span));
+                ctx.diagnostic(no_empty_diagnostic("block", finally_clause.span));
             }
             AstKind::SwitchStatement(switch) if switch.cases.is_empty() => {
-                ctx.diagnostic(NoEmptyDiagnostic("switch", switch.span));
+                ctx.diagnostic(no_empty_diagnostic("switch", switch.span));
             }
             _ => {}
         }
diff --git a/crates/oxc_linter/src/rules/eslint/no_empty_character_class.rs b/crates/oxc_linter/src/rules/eslint/no_empty_character_class.rs
index 8c85d3d6b433..c2a3d6a63777 100644
--- a/crates/oxc_linter/src/rules/eslint/no_empty_character_class.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_empty_character_class.rs
@@ -1,20 +1,19 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 // Ported from https://github.com/eslint/eslint/blob/main/lib/rules/no-empty-character-class.js
 use lazy_static::lazy_static;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use regex::Regex;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-empty-character-class): Empty character class")]
-#[diagnostic(severity(warning), help("Try to remove empty character class `[]` in regexp literal"))]
-struct NoEmptyCharacterClassDiagnostic(#[label] pub Span);
+fn no_empty_character_class_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-empty-character-class): Empty character class")
+        .with_help("Try to remove empty character class `[]` in regexp literal")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoEmptyCharacterClass;
@@ -52,7 +51,7 @@ impl Rule for NoEmptyCharacterClass {
 
         if let AstKind::RegExpLiteral(lit) = node.kind() {
             if !NO_EMPTY_CLASS_REGEX_PATTERN.is_match(&lit.regex.pattern) {
-                ctx.diagnostic(NoEmptyCharacterClassDiagnostic(lit.span));
+                ctx.diagnostic(no_empty_character_class_diagnostic(lit.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/eslint/no_empty_function.rs b/crates/oxc_linter/src/rules/eslint/no_empty_function.rs
index 73b39e1d5f66..a6209a5b6c26 100644
--- a/crates/oxc_linter/src/rules/eslint/no_empty_function.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_empty_function.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-empty-function): Disallow empty functions")]
-#[diagnostic(severity(warning), help("Unexpected empty function block"))]
-struct NoEmptyFunctionDiagnostic(#[label] pub Span);
+fn no_empty_function_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-empty-function): Disallow empty functions")
+        .with_help("Unexpected empty function block")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoEmptyFunction;
@@ -41,7 +40,7 @@ impl Rule for NoEmptyFunction {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::FunctionBody(fb) = node.kind() {
             if fb.is_empty() && !ctx.semantic().trivias().has_comments_between(fb.span) {
-                ctx.diagnostic(NoEmptyFunctionDiagnostic(fb.span));
+                ctx.diagnostic(no_empty_function_diagnostic(fb.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/eslint/no_empty_pattern.rs b/crates/oxc_linter/src/rules/eslint/no_empty_pattern.rs
index 42c36adafa5d..b0a61bb4e91f 100644
--- a/crates/oxc_linter/src/rules/eslint/no_empty_pattern.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_empty_pattern.rs
@@ -1,20 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-empty-pattern): Disallow empty destructuring patterns.")]
-#[diagnostic(
-    severity(warning),
-    help("Passing `null` or `undefined` will result in runtime error because `null` and `undefined` cannot be destructured.")
-)]
-struct NoEmptyPatternDiagnostic(&'static str, #[label("Empty {0} binding pattern")] pub Span);
+fn no_empty_pattern_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-empty-pattern): Disallow empty destructuring patterns.")
+        .with_help("Passing `null` or `undefined` will result in runtime error because `null` and `undefined` cannot be destructured.")
+        .with_labels([LabeledSpan::new_with_span(Some(format!("Empty {x0} binding pattern")), span1)])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoEmptyPattern;
@@ -84,7 +80,7 @@ impl Rule for NoEmptyPattern {
             AstKind::ObjectPattern(object) if object.is_empty() => ("object", object.span),
             _ => return,
         };
-        ctx.diagnostic(NoEmptyPatternDiagnostic(pattern_type, span));
+        ctx.diagnostic(no_empty_pattern_diagnostic(pattern_type, span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/eslint/no_empty_static_block.rs b/crates/oxc_linter/src/rules/eslint/no_empty_static_block.rs
index 93b14f0ede8c..1a5530518d97 100644
--- a/crates/oxc_linter/src/rules/eslint/no_empty_static_block.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_empty_static_block.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-empty-static-block): Disallow empty static blocks")]
-#[diagnostic(severity(warning), help("Unexpected empty static block."))]
-struct NoEmptyStaticBlockDiagnostic(#[label] pub Span);
+fn no_empty_static_block_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-empty-static-block): Disallow empty static blocks")
+        .with_help("Unexpected empty static block.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoEmptyStaticBlock;
@@ -44,7 +43,7 @@ impl Rule for NoEmptyStaticBlock {
                 if ctx.semantic().trivias().has_comments_between(static_block.span) {
                     return;
                 }
-                ctx.diagnostic(NoEmptyStaticBlockDiagnostic(static_block.span));
+                ctx.diagnostic(no_empty_static_block_diagnostic(static_block.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/eslint/no_eq_null.rs b/crates/oxc_linter/src/rules/eslint/no_eq_null.rs
index 7868abd54bc7..80408e36e243 100644
--- a/crates/oxc_linter/src/rules/eslint/no_eq_null.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_eq_null.rs
@@ -1,8 +1,6 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::BinaryOperator;
@@ -10,13 +8,11 @@ use std::fmt::Debug;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-eq-null): Use '===' to compare with null")]
-#[diagnostic(
-    severity(warning),
-    help("Disallow `null` comparisons without type-checking operators.")
-)]
-struct NoEqNullDiagnostic(#[label] pub Span);
+fn no_eq_null_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-eq-null): Use '===' to compare with null")
+        .with_help("Disallow `null` comparisons without type-checking operators.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoEqNull;
@@ -53,7 +49,7 @@ impl Rule for NoEqNull {
                     & binary_expression.left.is_null()
                     & bad_operator
             {
-                ctx.diagnostic(NoEqNullDiagnostic(Span::new(
+                ctx.diagnostic(no_eq_null_diagnostic(Span::new(
                     binary_expression.span.start,
                     binary_expression.span.end,
                 )));
diff --git a/crates/oxc_linter/src/rules/eslint/no_eval.rs b/crates/oxc_linter/src/rules/eslint/no_eval.rs
index 10ad075b0257..ba5f1df04e44 100644
--- a/crates/oxc_linter/src/rules/eslint/no_eval.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_eval.rs
@@ -1,20 +1,17 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 // Ported from https://github.com/eslint/eslint/tree/main/lib/rules/no-eval.js
 
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNode;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-eval): eval can be harmful.")]
-#[diagnostic(severity(warning))]
-struct NoEvalDiagnostic(#[label] pub Span);
+fn no_eval_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-eval): eval can be harmful.").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoEval {
@@ -66,7 +63,7 @@ impl Rule for NoEval {
 
         if let AstKind::IdentifierReference(ident) = kind {
             if ident.name == "eval" {
-                ctx.diagnostic(NoEvalDiagnostic(ident.span));
+                ctx.diagnostic(no_eval_diagnostic(ident.span));
             }
             return;
         }
@@ -116,7 +113,7 @@ impl Rule for NoEval {
             };
         }
 
-        ctx.diagnostic(NoEvalDiagnostic(eval_span));
+        ctx.diagnostic(no_eval_diagnostic(eval_span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/eslint/no_ex_assign.rs b/crates/oxc_linter/src/rules/eslint/no_ex_assign.rs
index 8a74c706dafc..9574d785e370 100644
--- a/crates/oxc_linter/src/rules/eslint/no_ex_assign.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_ex_assign.rs
@@ -1,17 +1,14 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::SymbolId;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-ex-assign): Do not assign to the exception parameter.")]
-#[diagnostic(severity(warning), help("If a catch clause in a try statement accidentally (or purposely) assigns another value to the exception parameter, it is impossible to refer to the error from that point on. Since there is no arguments object to offer alternative access to this data, assignment of the parameter is absolutely destructive."))]
-struct NoExAssignDiagnostic(#[label] pub Span);
+fn no_ex_assign_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-ex-assign): Do not assign to the exception parameter.").with_help("If a catch clause in a try statement accidentally (or purposely) assigns another value to the exception parameter, it is impossible to refer to the error from that point on. Since there is no arguments object to offer alternative access to this data, assignment of the parameter is absolutely destructive.").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoExAssign;
@@ -45,7 +42,7 @@ impl Rule for NoExAssign {
         if symbol_table.get_flag(symbol_id).is_catch_variable() {
             for reference in symbol_table.get_resolved_references(symbol_id) {
                 if reference.is_write() {
-                    ctx.diagnostic(NoExAssignDiagnostic(reference.span()));
+                    ctx.diagnostic(no_ex_assign_diagnostic(reference.span()));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/eslint/no_extra_boolean_cast.rs b/crates/oxc_linter/src/rules/eslint/no_extra_boolean_cast.rs
index d1ce266b882f..4896ae31deb2 100644
--- a/crates/oxc_linter/src/rules/eslint/no_extra_boolean_cast.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_extra_boolean_cast.rs
@@ -1,30 +1,24 @@
 use itertools::Itertools;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{LogicalOperator, UnaryOperator};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-extra-boolean-cast): Redundant double negation")]
-#[diagnostic(
-    severity(warning),
-    help("Remove the double negation as it will already be coerced to a boolean")
-)]
-struct NoExtraDoubleNegationCastDiagnostic(#[label] pub Span);
+fn no_extra_double_negation_cast_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-extra-boolean-cast): Redundant double negation")
+        .with_help("Remove the double negation as it will already be coerced to a boolean")
+        .with_labels([span0.into()])
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-extra-boolean-cast): Redundant Boolean call")]
-#[diagnostic(
-    severity(warning),
-    help("Remove the Boolean call as it will already be coerced to a boolean")
-)]
-struct NoExtraBooleanCastDiagnostic(#[label] pub Span);
+fn no_extra_boolean_cast_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-extra-boolean-cast): Redundant Boolean call")
+        .with_help("Remove the Boolean call as it will already be coerced to a boolean")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoExtraBooleanCast {
@@ -71,13 +65,15 @@ impl Rule for NoExtraBooleanCast {
                 if expr.callee.is_specific_id("Boolean")
                     && is_flagged_ctx(node, ctx, self.enforce_for_logical_operands) =>
             {
-                ctx.diagnostic(NoExtraBooleanCastDiagnostic(expr.span));
+                ctx.diagnostic(no_extra_boolean_cast_diagnostic(expr.span));
             }
             AstKind::UnaryExpression(unary) if unary.operator == UnaryOperator::LogicalNot => {
-                let Some(parent) = get_real_parent(node, ctx) else { return };
+                let Some(parent) = get_real_parent(node, ctx) else {
+                    return;
+                };
                 if matches!(parent.kind(), AstKind::UnaryExpression(p) if p.operator == UnaryOperator::LogicalNot && is_flagged_ctx(parent, ctx, self.enforce_for_logical_operands))
                 {
-                    ctx.diagnostic(NoExtraDoubleNegationCastDiagnostic(parent.kind().span()));
+                    ctx.diagnostic(no_extra_double_negation_cast_diagnostic(parent.kind().span()));
                 }
             }
             _ => {}
diff --git a/crates/oxc_linter/src/rules/eslint/no_fallthrough.rs b/crates/oxc_linter/src/rules/eslint/no_fallthrough.rs
index 356c57823b84..3cd4fa97b89c 100644
--- a/crates/oxc_linter/src/rules/eslint/no_fallthrough.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_fallthrough.rs
@@ -1,7 +1,3 @@
-// use oxc_diagnostics::{
-//     miette::{self, Diagnostic},
-//     thiserror::Error,
-// };
 use oxc_macros::declare_oxc_lint;
 // use oxc_span::Span;
 
@@ -70,10 +66,7 @@ fn test() {
         ("function foo() { switch(foo) { case 0: {return;}\n case 1: {return;} } }", None),
         ("switch(foo) { case 0: case 1: {break;} }", None),
         ("switch(foo) { }", None),
-        (
-            "switch(foo) { case 0: switch(bar) { case 2: break; } /* falls through */ case 1: break; }",
-            None,
-        ),
+        ("switch(foo) { case 0: switch(bar) { case 2: break; } /* falls through */ case 1: break; }", None),
         ("function foo() { switch(foo) { case 1: return a; a++; }}", None),
         ("switch (foo) { case 0: a(); /* falls through */ default:  b(); /* comment */ }", None),
         ("switch (foo) { case 0: a(); /* falls through */ default: /* comment */ b(); }", None),
@@ -82,10 +75,7 @@ fn test() {
         ("switch (foo) { case 0: try {} finally { break; } default: b(); }", None),
         ("switch (foo) { case 0: try { throw 0; } catch (err) { break; } default: b(); }", None),
         ("switch (foo) { case 0: do { throw 0; } while(a); default: b(); }", None),
-        (
-            "switch (foo) { case 0: a(); \n// eslint-disable-next-line no-fallthrough\n case 1: }",
-            None,
-        ),
+        ("switch (foo) { case 0: a(); \n// eslint-disable-next-line no-fallthrough\n case 1: }", None),
         (
             "switch(foo) { case 0: a(); /* no break */ case 1: b(); }",
             Some(serde_json::json!([{
@@ -116,22 +106,10 @@ fn test() {
                 "commentPattern": "break[\\s\\w]+omitted"
             }])),
         ),
-        (
-            "switch(foo) { case 0: \n\n\n case 1: b(); }",
-            Some(serde_json::json!([{ "allowEmptyCase": true }])),
-        ),
-        (
-            "switch(foo) { case 0: \n /* with comments */  \n case 1: b(); }",
-            Some(serde_json::json!([{ "allowEmptyCase": true }])),
-        ),
-        (
-            "switch (a) {\n case 1: ; break; \n case 3: }",
-            Some(serde_json::json!([{ "allowEmptyCase": true }])),
-        ),
-        (
-            "switch (a) {\n case 1: ; break; \n case 3: }",
-            Some(serde_json::json!([{ "allowEmptyCase": false }])),
-        ),
+        ("switch(foo) { case 0: \n\n\n case 1: b(); }", Some(serde_json::json!([{ "allowEmptyCase": true }]))),
+        ("switch(foo) { case 0: \n /* with comments */  \n case 1: b(); }", Some(serde_json::json!([{ "allowEmptyCase": true }]))),
+        ("switch (a) {\n case 1: ; break; \n case 3: }", Some(serde_json::json!([{ "allowEmptyCase": true }]))),
+        ("switch (a) {\n case 1: ; break; \n case 3: }", Some(serde_json::json!([{ "allowEmptyCase": false }]))),
     ];
 
     let fail = vec![
diff --git a/crates/oxc_linter/src/rules/eslint/no_func_assign.rs b/crates/oxc_linter/src/rules/eslint/no_func_assign.rs
index 8db5d9688df7..7e68cc475c5f 100644
--- a/crates/oxc_linter/src/rules/eslint/no_func_assign.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_func_assign.rs
@@ -1,18 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::SymbolId;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-func-assign): '{0}' is a function.")]
-#[diagnostic(severity(warning))]
-struct NoFuncAssignDiagnostic(CompactStr, #[label("{0} is re-assigned here")] pub Span);
+fn no_func_assign_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint(no-func-assign): '{x0}' is a function."))
+        .with_labels([LabeledSpan::new_with_span(Some(format!("{x0} is re-assigned here")), span1)])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoFuncAssign;
@@ -41,8 +39,8 @@ impl Rule for NoFuncAssign {
         if let AstKind::Function(_) = ctx.nodes().kind(decl) {
             for reference in symbol_table.get_resolved_references(symbol_id) {
                 if reference.is_write() {
-                    ctx.diagnostic(NoFuncAssignDiagnostic(
-                        symbol_table.get_name(symbol_id).into(),
+                    ctx.diagnostic(no_func_assign_diagnostic(
+                        symbol_table.get_name(symbol_id),
                         reference.span(),
                     ));
                 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_global_assign.rs b/crates/oxc_linter/src/rules/eslint/no_global_assign.rs
index 79a3e1b67bca..c972f9ee2108 100644
--- a/crates/oxc_linter/src/rules/eslint/no_global_assign.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_global_assign.rs
@@ -1,19 +1,19 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{CompactStr, Span};
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-global-assign): Read-only global '{0}' should not be modified.")]
-#[diagnostic(severity(warning))]
-struct NoGlobalAssignDiagnostic(
-    CompactStr,
-    #[label("Read-only global '{0}' should not be modified.")] pub Span,
-);
+fn no_global_assign_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(no-global-assign): Read-only global '{x0}' should not be modified."
+    ))
+    .with_labels([LabeledSpan::new_with_span(
+        Some(format!("Read-only global '{x0}' should not be modified.")),
+        span1,
+    )])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoGlobalAssign(Box<NoGlobalAssignConfig>);
@@ -72,7 +72,7 @@ impl Rule for NoGlobalAssign {
                     let name = reference.name();
 
                     if !self.excludes.contains(name) && ctx.env_contains_var(name) {
-                        ctx.diagnostic(NoGlobalAssignDiagnostic(name.clone(), reference.span()));
+                        ctx.diagnostic(no_global_assign_diagnostic(name, reference.span()));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/eslint/no_import_assign.rs b/crates/oxc_linter/src/rules/eslint/no_import_assign.rs
index 9b096d2bb6b2..ceacc42dfad8 100644
--- a/crates/oxc_linter/src/rules/eslint/no_import_assign.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_import_assign.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{AstNodeId, SymbolId};
 use oxc_span::{GetSpan, Span};
@@ -11,10 +9,11 @@ use phf::phf_set;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-import-assign): do not assign to imported bindings")]
-#[diagnostic(severity(warning), help("imported bindings are readonly"))]
-struct NoImportAssignDiagnostic(#[label] pub Span);
+fn no_import_assign_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-import-assign): do not assign to imported bindings")
+        .with_help("imported bindings are readonly")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoImportAssign;
@@ -77,7 +76,8 @@ impl Rule for NoImportAssign {
                         {
                             if let Some((span, _)) = expr.static_property_info() {
                                 if span != reference.span() {
-                                    return ctx.diagnostic(NoImportAssignDiagnostic(expr.span()));
+                                    return ctx
+                                        .diagnostic(no_import_assign_diagnostic(expr.span()));
                                 }
                             }
                         }
@@ -88,7 +88,7 @@ impl Rule for NoImportAssign {
                     || (is_namespace_specifier
                         && is_argument_of_well_known_mutation_function(reference.node_id(), ctx))
                 {
-                    ctx.diagnostic(NoImportAssignDiagnostic(reference.span()));
+                    ctx.diagnostic(no_import_assign_diagnostic(reference.span()));
                 }
             }
         }
@@ -110,9 +110,13 @@ fn is_argument_of_well_known_mutation_function(node_id: AstNodeId, ctx: &LintCon
     let call_expression_node =
         ctx.nodes().parent_node(node_id).and_then(|node| ctx.nodes().parent_kind(node.id()));
 
-    let Some(AstKind::CallExpression(expr)) = call_expression_node else { return false };
+    let Some(AstKind::CallExpression(expr)) = call_expression_node else {
+        return false;
+    };
 
-    let Some(member_expr) = &expr.callee.get_member_expr() else { return false };
+    let Some(member_expr) = &expr.callee.get_member_expr() else {
+        return false;
+    };
 
     if let Expression::Identifier(ident) = member_expr.object() {
         let Some(property_name) = member_expr.static_property_name() else {
diff --git a/crates/oxc_linter/src/rules/eslint/no_inner_declarations.rs b/crates/oxc_linter/src/rules/eslint/no_inner_declarations.rs
index 329296095243..2a3219f4e99f 100644
--- a/crates/oxc_linter/src/rules/eslint/no_inner_declarations.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_inner_declarations.rs
@@ -1,19 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint(no-inner-declarations): Variable or `function` declarations are not allowed in nested blocks"
-)]
-#[diagnostic(severity(warning), help("Move {0} declaration to {1} root"))]
-struct NoInnerDeclarationsDiagnostic(&'static str, &'static str, #[label] pub Span);
+fn no_inner_declarations_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-inner-declarations): Variable or `function` declarations are not allowed in nested blocks")
+        .with_help(format!("Move {x0} declaration to {x1} root"))
+        .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoInnerDeclarations {
@@ -123,7 +120,7 @@ impl Rule for NoInnerDeclarations {
             }
         }
 
-        ctx.diagnostic(NoInnerDeclarationsDiagnostic(decl_type, body, span));
+        ctx.diagnostic(no_inner_declarations_diagnostic(decl_type, body, span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/eslint/no_irregular_whitespace.rs b/crates/oxc_linter/src/rules/eslint/no_irregular_whitespace.rs
index 019c80ad9016..61b7ec61cd25 100644
--- a/crates/oxc_linter/src/rules/eslint/no_irregular_whitespace.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_irregular_whitespace.rs
@@ -1,16 +1,15 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-irregular-whitespace): Unexpected irregular whitespace")]
-#[diagnostic(severity(warning), help("Try to remove the irregular whitespace"))]
-struct NoIrregularWhitespaceDiagnostic(#[label] pub Span);
+fn no_irregular_whitespace_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-irregular-whitespace): Unexpected irregular whitespace")
+        .with_help("Try to remove the irregular whitespace")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoIrregularWhitespace;
@@ -37,7 +36,7 @@ impl Rule for NoIrregularWhitespace {
     fn run_once(&self, ctx: &LintContext) {
         let irregular_whitespaces = ctx.semantic().trivias().irregular_whitespaces();
         for irregular_whitespace in irregular_whitespaces {
-            ctx.diagnostic(NoIrregularWhitespaceDiagnostic(*irregular_whitespace));
+            ctx.diagnostic(no_irregular_whitespace_diagnostic(*irregular_whitespace));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_iterator.rs b/crates/oxc_linter/src/rules/eslint/no_iterator.rs
index 91a67b92088d..270b6d0d3e3c 100644
--- a/crates/oxc_linter/src/rules/eslint/no_iterator.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_iterator.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-iterator): Reserved name '__iterator__'")]
-#[diagnostic(severity(warning), help("Disallow the use of the `__iterator__` property."))]
-struct NoIteratorDiagnostic(#[label] pub Span);
+fn no_iterator_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-iterator): Reserved name '__iterator__'")
+        .with_help("Disallow the use of the `__iterator__` property.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoIterator;
@@ -35,10 +34,12 @@ declare_oxc_lint!(
 
 impl Rule for NoIterator {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::MemberExpression(member_expression) = node.kind() else { return };
+        let AstKind::MemberExpression(member_expression) = node.kind() else {
+            return;
+        };
         if let Some(static_property_name) = member_expression.static_property_name() {
             if static_property_name == "__iterator__" {
-                ctx.diagnostic(NoIteratorDiagnostic(Span::new(
+                ctx.diagnostic(no_iterator_diagnostic(Span::new(
                     member_expression.span().start,
                     member_expression.span().end,
                 )));
diff --git a/crates/oxc_linter/src/rules/eslint/no_loss_of_precision.rs b/crates/oxc_linter/src/rules/eslint/no_loss_of_precision.rs
index ef39f2fb6191..9c50c7759fe7 100644
--- a/crates/oxc_linter/src/rules/eslint/no_loss_of_precision.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_loss_of_precision.rs
@@ -1,19 +1,19 @@
 use oxc_ast::ast::NumericLiteral;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use std::borrow::Cow;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-loss-of-precision): This number literal will lose precision at runtime.")]
-#[diagnostic(severity(warning))]
-struct NoLossOfPrecisionDiagnostic(#[label] pub Span);
+fn no_loss_of_precision_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(no-loss-of-precision): This number literal will lose precision at runtime.",
+    )
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoLossOfPrecision;
@@ -41,7 +41,7 @@ impl Rule for NoLossOfPrecision {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         match node.kind() {
             AstKind::NumericLiteral(node) if Self::lose_precision(node) => {
-                ctx.diagnostic(NoLossOfPrecisionDiagnostic(node.span));
+                ctx.diagnostic(no_loss_of_precision_diagnostic(node.span));
             }
             _ => {}
         }
@@ -211,7 +211,9 @@ impl NoLossOfPrecision {
 
     fn base_ten_loses_precision(node: &'_ NumericLiteral) -> bool {
         let raw = Self::get_raw(node);
-        let Some(raw) = Self::normalize(&raw) else { return true };
+        let Some(raw) = Self::normalize(&raw) else {
+            return true;
+        };
 
         if raw.frac.len() >= 100 {
             return true;
@@ -221,7 +223,9 @@ impl NoLossOfPrecision {
             (false, 0) => node.value.to_string(),
             (false, precision) => format!("{:.1$}", node.value, precision),
         };
-        let Some(stored) = Self::normalize(&stored) else { return true };
+        let Some(stored) = Self::normalize(&stored) else {
+            return true;
+        };
         raw != stored
     }
 
diff --git a/crates/oxc_linter/src/rules/eslint/no_new_native_nonconstructor.rs b/crates/oxc_linter/src/rules/eslint/no_new_native_nonconstructor.rs
index 877b81e856bb..c806cc640e57 100644
--- a/crates/oxc_linter/src/rules/eslint/no_new_native_nonconstructor.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_new_native_nonconstructor.rs
@@ -1,17 +1,17 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-new-native-nonconstructor): `{0}` cannot be called as a constructor.")]
-#[diagnostic(severity(warning))]
-struct NoNewNativeNonconstructorDiagnostic(CompactStr, #[label] pub Span);
+fn no_new_native_nonconstructor_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(no-new-native-nonconstructor): `{x0}` cannot be called as a constructor."
+    ))
+    .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoNewNativeNonconstructor;
@@ -40,15 +40,19 @@ declare_oxc_lint!(
 
 impl Rule for NoNewNativeNonconstructor {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::NewExpression(expr) = node.kind() else { return };
-        let Expression::Identifier(ident) = &expr.callee else { return };
+        let AstKind::NewExpression(expr) = node.kind() else {
+            return;
+        };
+        let Expression::Identifier(ident) = &expr.callee else {
+            return;
+        };
         if matches!(ident.name.as_str(), "Symbol" | "BigInt")
             && ctx.semantic().is_reference_to_global_variable(ident)
         {
             let start = expr.span.start;
             let end = start + 3;
-            ctx.diagnostic(NoNewNativeNonconstructorDiagnostic(
-                ident.name.to_compact_str(),
+            ctx.diagnostic(no_new_native_nonconstructor_diagnostic(
+                ident.name.as_str(),
                 Span::new(start, end),
             ));
         }
diff --git a/crates/oxc_linter/src/rules/eslint/no_new_wrappers.rs b/crates/oxc_linter/src/rules/eslint/no_new_wrappers.rs
index 6e45a329af9b..26ceb8fd51b9 100644
--- a/crates/oxc_linter/src/rules/eslint/no_new_wrappers.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_new_wrappers.rs
@@ -1,22 +1,16 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint(no-new-wrappers): Disallow new operators with the String, Number, and Boolean objects"
-)]
-#[diagnostic(
-    severity(warning),
-    help("do not use {0} as a constructor, consider removing the new operator.")
-)]
-struct NoNewWrappersDiagnostic(CompactStr, #[label] pub Span);
+fn no_new_wrappers_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-new-wrappers): Disallow new operators with the String, Number, and Boolean objects")
+        .with_help(format!("do not use {x0} as a constructor, consider removing the new operator."))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoNewWrappers;
@@ -42,12 +36,16 @@ declare_oxc_lint!(
 
 impl Rule for NoNewWrappers {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::NewExpression(expr) = node.kind() else { return };
-        let Expression::Identifier(ident) = &expr.callee else { return };
+        let AstKind::NewExpression(expr) = node.kind() else {
+            return;
+        };
+        let Expression::Identifier(ident) = &expr.callee else {
+            return;
+        };
         if (ident.name == "String" || ident.name == "Number" || ident.name == "Boolean")
             && ctx.semantic().is_reference_to_global_variable(ident)
         {
-            ctx.diagnostic(NoNewWrappersDiagnostic(ident.name.to_compact_str(), expr.span));
+            ctx.diagnostic(no_new_wrappers_diagnostic(ident.name.as_str(), expr.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_nonoctal_decimal_escape.rs b/crates/oxc_linter/src/rules/eslint/no_nonoctal_decimal_escape.rs
index fa8e18e84ad3..07d5573f4100 100644
--- a/crates/oxc_linter/src/rules/eslint/no_nonoctal_decimal_escape.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_nonoctal_decimal_escape.rs
@@ -1,30 +1,26 @@
 use lazy_static::lazy_static;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use regex::{Captures, Regex};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoNonoctalDecimalEscapeDiagnostic {
-    #[error("eslint(no-nonoctal-decimal-escape): Don't use '{0}' escape sequence.")]
-    #[diagnostic(
-        severity(warning),
-        help("Replace '{0}' with '{1}'. This maintains the current functionality.")
-    )]
-    Replacement(String, String, #[label] Span),
-
-    #[error("eslint(no-nonoctal-decimal-escape): Don't use '{0}' escape sequence.")]
-    #[diagnostic(
-        severity(warning),
-        help("Replace '{0}' with '{1}' to include the actual backslash character.")
-    )]
-    EscapeBackslash(String, String, #[label] Span),
+fn replacement(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(no-nonoctal-decimal-escape): Don't use '{x0}' escape sequence."
+    ))
+    .with_help(format!("Replace '{x0}' with '{x1}'. This maintains the current functionality."))
+    .with_labels([span2.into()])
+}
+
+fn escape_backslash(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(no-nonoctal-decimal-escape): Don't use '{x0}' escape sequence."
+    ))
+    .with_help(format!("Replace '{x0}' with '{x1}' to include the actual backslash character."))
+    .with_labels([span2.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -115,28 +111,24 @@ fn check_string(ctx: &LintContext<'_>, string: &str) {
 
         if let Some(prev_match) = previous_escape {
             if prev_match.as_str().eq("\\0") {
-                ctx.diagnostic(NoNonoctalDecimalEscapeDiagnostic::Replacement(
-                    prev_match.as_str().to_string() + decimal_escape_str,
-                    "\\u00008".to_string(),
+                ctx.diagnostic(replacement(
+                    &(prev_match.as_str().to_string() + decimal_escape_str),
+                    "\\u00008",
                     Span::new(prev_match.start() as u32, decimal_escape_span.end),
                 ));
-                ctx.diagnostic(NoNonoctalDecimalEscapeDiagnostic::Replacement(
-                    decimal_escape_str.to_string(),
-                    "\\u0038".to_string(),
-                    decimal_escape_span,
-                ));
+                ctx.diagnostic(replacement(decimal_escape_str, "\\u0038", decimal_escape_span));
             }
         } else {
-            ctx.diagnostic(NoNonoctalDecimalEscapeDiagnostic::Replacement(
-                decimal_escape_str.to_string(),
-                decimal_escape_str[1..].to_string(),
+            ctx.diagnostic(replacement(
+                decimal_escape_str,
+                &decimal_escape_str[1..],
                 decimal_escape_span,
             ));
         }
 
-        ctx.diagnostic(NoNonoctalDecimalEscapeDiagnostic::EscapeBackslash(
-            decimal_escape_str.to_string(),
-            format!("\\{decimal_escape_str}"),
+        ctx.diagnostic(escape_backslash(
+            decimal_escape_str,
+            &format!("\\{decimal_escape_str}"),
             decimal_escape_span,
         ));
 
diff --git a/crates/oxc_linter/src/rules/eslint/no_obj_calls.rs b/crates/oxc_linter/src/rules/eslint/no_obj_calls.rs
index bcce8e1a73c4..1d5bdc32583b 100644
--- a/crates/oxc_linter/src/rules/eslint/no_obj_calls.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_obj_calls.rs
@@ -2,23 +2,24 @@ use oxc_ast::{
     ast::{match_member_expression, Expression, IdentifierReference, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{AstNode, ScopeId};
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
 const GLOBAL_THIS: &str = "globalThis";
 const NON_CALLABLE_GLOBALS: [&str; 5] = ["Atomics", "Intl", "JSON", "Math", "Reflect"];
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-obj-calls): Disallow calling some global objects as functions")]
-#[diagnostic(severity(warning), help("{0} is not a function."))]
-struct NoObjCallsDiagnostic(CompactStr, #[label] pub Span);
+fn no_obj_calls_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(no-obj-calls): Disallow calling some global objects as functions",
+    )
+    .with_help(format!("{x0} is not a function."))
+    .with_labels([span1.into()])
+}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct NoObjCalls;
@@ -139,7 +140,7 @@ impl Rule for NoObjCalls {
                     resolve_global_binding(ident, node.scope_id(), ctx)
                 {
                     if is_global_obj(top_level_reference) {
-                        ctx.diagnostic(NoObjCallsDiagnostic(ident.name.to_compact_str(), span));
+                        ctx.diagnostic(no_obj_calls_diagnostic(ident.name.as_str(), span));
                     }
                 }
             }
@@ -148,7 +149,7 @@ impl Rule for NoObjCalls {
                 // handle new globalThis.Math(), globalThis.Math(), etc
                 if let Some(global_member) = global_this_member(callee.to_member_expression()) {
                     if is_global_obj(global_member) {
-                        ctx.diagnostic(NoObjCallsDiagnostic(global_member.into(), span));
+                        ctx.diagnostic(no_obj_calls_diagnostic(global_member, span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/eslint/no_proto.rs b/crates/oxc_linter/src/rules/eslint/no_proto.rs
index b5cd4c8a78a3..a67992aebb4d 100644
--- a/crates/oxc_linter/src/rules/eslint/no_proto.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_proto.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-proto): The '__proto__' property is deprecated")]
-#[diagnostic(severity(warning), help("Disallow the use of the `__proto__` property."))]
-struct NoProtoDiagnostic(#[label] pub Span);
+fn no_proto_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-proto): The '__proto__' property is deprecated")
+        .with_help("Disallow the use of the `__proto__` property.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoProto;
@@ -41,10 +40,12 @@ declare_oxc_lint!(
 
 impl Rule for NoProto {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::MemberExpression(member_expression) = node.kind() else { return };
+        let AstKind::MemberExpression(member_expression) = node.kind() else {
+            return;
+        };
         if let Some(static_property_name) = member_expression.static_property_name() {
             if static_property_name == "__proto__" {
-                ctx.diagnostic(NoProtoDiagnostic(Span::new(
+                ctx.diagnostic(no_proto_diagnostic(Span::new(
                     member_expression.span().start,
                     member_expression.span().end,
                 )));
diff --git a/crates/oxc_linter/src/rules/eslint/no_prototype_builtins.rs b/crates/oxc_linter/src/rules/eslint/no_prototype_builtins.rs
index c9e7fb5a724e..d4ef4cad328b 100644
--- a/crates/oxc_linter/src/rules/eslint/no_prototype_builtins.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_prototype_builtins.rs
@@ -1,22 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint(no-prototype-builtins): do not access Object.prototype method {0:?} from target object"
-)]
-#[diagnostic(
-    severity(warning),
-    help("to avoid prototype pollution, use `Object.prototype.{0}.call` instead")
-)]
-struct NoPrototypeBuiltinsDiagnostic(String, #[label] pub Span);
+fn no_prototype_builtins_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint(no-prototype-builtins): do not access Object.prototype method {x0:?} from target object"))
+        .with_help(format!("to avoid prototype pollution, use `Object.prototype.{x0}.call` instead"))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoPrototypeBuiltins;
@@ -51,14 +45,17 @@ const DISALLOWED_PROPS: &[&str; 3] = &["hasOwnProperty", "isPrototypeOf", "prope
 
 impl Rule for NoPrototypeBuiltins {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(expr) = node.kind() else { return };
-        let Some(member_expr) = expr.callee.get_member_expr() else { return };
-        let Some(prop_name) = member_expr.static_property_name() else { return };
+        let AstKind::CallExpression(expr) = node.kind() else {
+            return;
+        };
+        let Some(member_expr) = expr.callee.get_member_expr() else {
+            return;
+        };
+        let Some(prop_name) = member_expr.static_property_name() else {
+            return;
+        };
         if DISALLOWED_PROPS.contains(&prop_name) {
-            ctx.diagnostic(NoPrototypeBuiltinsDiagnostic(
-                prop_name.to_string(),
-                member_expr.span(),
-            ));
+            ctx.diagnostic(no_prototype_builtins_diagnostic(prop_name, member_expr.span()));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_redeclare.rs b/crates/oxc_linter/src/rules/eslint/no_redeclare.rs
index 70ece4bd66ec..7c74a78ee73e 100644
--- a/crates/oxc_linter/src/rules/eslint/no_redeclare.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_redeclare.rs
@@ -2,31 +2,31 @@ use oxc_ast::{
     ast::{BindingIdentifier, BindingPatternKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-redeclare): '{0}' is already defined.")]
-#[diagnostic(severity(warning))]
-struct NoRedeclareDiagnostic(
-    CompactStr,
-    #[label("'{0}' is already defined.")] pub Span,
-    #[label("It can not be redeclare here.")] pub Span,
-);
+fn no_redeclare_diagnostic(x0: &str, span1: Span, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint(no-redeclare): '{x0}' is already defined.")).with_labels(
+        [
+            LabeledSpan::new_with_span(Some(format!("'{x0}' is already defined.")), span1),
+            LabeledSpan::new_with_span(Some("It can not be redeclare here.".into()), span2),
+        ],
+    )
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-redeclare): '{0}' is already defined as a built-in global variable.")]
-#[diagnostic(severity(warning))]
-struct NoRedeclareAsBuiltiInDiagnostic(
-    CompactStr,
-    #[label("'{0}' is already defined as a built-in global variable.")] pub Span,
-);
+fn no_redeclare_as_builti_in_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(no-redeclare): '{x0}' is already defined as a built-in global variable."
+    ))
+    .with_labels([LabeledSpan::new_with_span(
+        Some(format!("'{x0}' is already defined as a built-in global variable.")),
+        span1,
+    )])
+}
 
 // #[derive(Debug, Error, Diagnostic)]
 // #[error("eslint(no-redeclare): '{0}' is already defined by a variable declaration.")]
@@ -105,12 +105,9 @@ impl Rule for NoRedeclare {
 impl NoRedeclare {
     fn report_diagnostic(&self, ctx: &LintContext, span: Span, ident: &BindingIdentifier) {
         if self.built_in_globals && ctx.env_contains_var(&ident.name) {
-            ctx.diagnostic(NoRedeclareAsBuiltiInDiagnostic(
-                ident.name.to_compact_str(),
-                ident.span,
-            ));
+            ctx.diagnostic(no_redeclare_as_builti_in_diagnostic(ident.name.as_str(), ident.span));
         } else {
-            ctx.diagnostic(NoRedeclareDiagnostic(ident.name.to_compact_str(), ident.span, span));
+            ctx.diagnostic(no_redeclare_diagnostic(ident.name.as_str(), ident.span, span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_regex_spaces.rs b/crates/oxc_linter/src/rules/eslint/no_regex_spaces.rs
index 9286dfc3ecb5..972a4aa70098 100644
--- a/crates/oxc_linter/src/rules/eslint/no_regex_spaces.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_regex_spaces.rs
@@ -3,19 +3,18 @@ use oxc_ast::{
     ast::{Argument, CallExpression, NewExpression, RegExpLiteral},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-regex-spaces): Spaces are hard to count.")]
-#[diagnostic(severity(warning), help("Use a quantifier, e.g. {{2}}"))]
-struct NoRegexSpacesDiagnostic(#[label] pub Span);
+fn no_regex_spaces_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-regex-spaces): Spaces are hard to count.")
+        .with_help("Use a quantifier, e.g. {2}")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoRegexSpaces;
@@ -47,19 +46,19 @@ impl Rule for NoRegexSpaces {
         match node.kind() {
             AstKind::RegExpLiteral(lit) => {
                 if let Some(span) = Self::find_literal_to_report(lit) {
-                    ctx.diagnostic(NoRegexSpacesDiagnostic(span)); // /a  b/
+                    ctx.diagnostic(no_regex_spaces_diagnostic(span)); // /a  b/
                 }
             }
 
             AstKind::CallExpression(expr) if Self::is_regexp_call_expression(expr) => {
                 if let Some(span) = Self::find_expr_to_report(&expr.arguments) {
-                    ctx.diagnostic(NoRegexSpacesDiagnostic(span)); // RegExp('a  b')
+                    ctx.diagnostic(no_regex_spaces_diagnostic(span)); // RegExp('a  b')
                 }
             }
 
             AstKind::NewExpression(expr) if Self::is_regexp_new_expression(expr) => {
                 if let Some(span) = Self::find_expr_to_report(&expr.arguments) {
-                    ctx.diagnostic(NoRegexSpacesDiagnostic(span)); // new RegExp('a  b')
+                    ctx.diagnostic(no_regex_spaces_diagnostic(span)); // new RegExp('a  b')
                 }
             }
 
diff --git a/crates/oxc_linter/src/rules/eslint/no_script_url.rs b/crates/oxc_linter/src/rules/eslint/no_script_url.rs
index b90b6be7716e..4a2e43f13cc4 100644
--- a/crates/oxc_linter/src/rules/eslint/no_script_url.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_script_url.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-script-url): Script URL is a form of eval")]
-#[diagnostic(severity(warning), help("Disallow `javascript:` urls"))]
-struct NoScriptUrlDiagnostic(#[label] pub Span);
+fn no_script_url_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-script-url): Script URL is a form of eval")
+        .with_help("Disallow `javascript:` urls")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoScriptUrl;
@@ -65,7 +64,7 @@ impl Rule for NoScriptUrl {
 }
 
 fn emit_diagnostic(ctx: &LintContext, span: Span) {
-    ctx.diagnostic(NoScriptUrlDiagnostic(Span::new(span.start, span.end)));
+    ctx.diagnostic(no_script_url_diagnostic(Span::new(span.start, span.end)));
 }
 
 fn is_tagged_template_expression(ctx: &LintContext, node: &AstNode, literal_span: Span) -> bool {
diff --git a/crates/oxc_linter/src/rules/eslint/no_self_assign.rs b/crates/oxc_linter/src/rules/eslint/no_self_assign.rs
index c75836516c72..5490d5d74580 100644
--- a/crates/oxc_linter/src/rules/eslint/no_self_assign.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_self_assign.rs
@@ -6,20 +6,18 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::AssignmentOperator;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-self-assign): this expression is assigned to itself")]
-#[diagnostic(severity(warning))]
-struct NoSelfAssignDiagnostic(#[label] pub Span);
+fn no_self_assign_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-self-assign): this expression is assigned to itself")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Clone)]
 pub struct NoSelfAssign {
@@ -63,7 +61,9 @@ impl Rule for NoSelfAssign {
     }
 
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::AssignmentExpression(assignment) = node.kind() else { return };
+        let AstKind::AssignmentExpression(assignment) = node.kind() else {
+            return;
+        };
         if matches!(
             assignment.operator,
             AssignmentOperator::Assign
@@ -91,14 +91,14 @@ impl NoSelfAssign {
                         || matches!(simple_assignment_target, SimpleAssignmentTarget::AssignmentTargetIdentifier(id1) if id1.name == id2.name);
 
                     if self_assign {
-                        ctx.diagnostic(NoSelfAssignDiagnostic(right.span()));
+                        ctx.diagnostic(no_self_assign_diagnostic(right.span()));
                     }
                 }
 
                 if let Some(member_target) = simple_assignment_target.as_member_expression() {
                     if let Some(member_expr) = right.without_parenthesized().get_member_expr() {
                         if self.is_member_expression_same_reference(member_expr, member_target) {
-                            ctx.diagnostic(NoSelfAssignDiagnostic(member_expr.span()));
+                            ctx.diagnostic(no_self_assign_diagnostic(member_expr.span()));
                         }
                     }
                 }
@@ -240,7 +240,7 @@ impl NoSelfAssign {
                         if key.static_name().is_some_and(|name| name == id1.binding.name) {
                             if let Expression::Identifier(id2) = expr.without_parenthesized() {
                                 if id1.binding.name == id2.name {
-                                    ctx.diagnostic(NoSelfAssignDiagnostic(*span));
+                                    ctx.diagnostic(no_self_assign_diagnostic(*span));
                                 }
                             }
                         }
diff --git a/crates/oxc_linter/src/rules/eslint/no_self_compare.rs b/crates/oxc_linter/src/rules/eslint/no_self_compare.rs
index b11c2f31123b..294847a6390c 100644
--- a/crates/oxc_linter/src/rules/eslint/no_self_compare.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_self_compare.rs
@@ -1,20 +1,18 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{ast_util::calculate_hash, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-self-compare): Disallow comparisons where both sides are exactly the same")]
-#[diagnostic(
-    severity(warning),
-    help("If you are testing for NaN, you can use Number.isNaN function.")
-)]
-struct NoSelfCompareDiagnostic(#[label] pub Span, #[label] pub Span);
+fn no_self_compare_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(no-self-compare): Disallow comparisons where both sides are exactly the same",
+    )
+    .with_help("If you are testing for NaN, you can use Number.isNaN function.")
+    .with_labels([span0.into(), span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoSelfCompare;
@@ -43,7 +41,9 @@ declare_oxc_lint!(
 
 impl Rule for NoSelfCompare {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::BinaryExpression(binary_expr) = node.kind() else { return };
+        let AstKind::BinaryExpression(binary_expr) = node.kind() else {
+            return;
+        };
         if !binary_expr.operator.is_compare() && !binary_expr.operator.is_equality() {
             return;
         }
@@ -51,7 +51,7 @@ impl Rule for NoSelfCompare {
         let right = calculate_hash(&binary_expr.right);
 
         if left == right {
-            ctx.diagnostic(NoSelfCompareDiagnostic(
+            ctx.diagnostic(no_self_compare_diagnostic(
                 binary_expr.left.span(),
                 binary_expr.right.span(),
             ));
diff --git a/crates/oxc_linter/src/rules/eslint/no_setter_return.rs b/crates/oxc_linter/src/rules/eslint/no_setter_return.rs
index 4bb5cdac69dc..565130dd3103 100644
--- a/crates/oxc_linter/src/rules/eslint/no_setter_return.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_setter_return.rs
@@ -1,16 +1,15 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-setter-return): Setter cannot return a value")]
-struct NoSetterReturnDiagnostic(#[label] pub Span);
+fn no_setter_return_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-setter-return): Setter cannot return a value")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoSetterReturn;
@@ -41,9 +40,11 @@ declare_oxc_lint!(
 
 impl Rule for NoSetterReturn {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::ReturnStatement(stmt) = node.kind() else { return };
+        let AstKind::ReturnStatement(stmt) = node.kind() else {
+            return;
+        };
         if stmt.argument.is_some() && ctx.scopes().get_flags(node.scope_id()).is_set_accessor() {
-            ctx.diagnostic(NoSetterReturnDiagnostic(stmt.span));
+            ctx.diagnostic(no_setter_return_diagnostic(stmt.span));
         }
     }
 }
@@ -68,10 +69,7 @@ fn test() {
         ("return 1;", None),
         ("return 1;", None),
         ("return 1; function foo(){ return 1; } return 1;", None),
-        (
-            "function foo(){} return 1; var bar = function*(){ return 1; }; return 1; var baz = () => {}; return 1;",
-            None,
-        ),
+        ("function foo(){} return 1; var bar = function*(){ return 1; }; return 1; var baz = () => {}; return 1;", None),
         ("({ set foo(val) { return; } })", None),
         ("({ set foo(val) { if (val) { return; } } })", None),
         ("class A { set foo(val) { return; } }", None),
@@ -118,10 +116,7 @@ fn test() {
         ("(class { set foo(val = (v) => 1) {} })", None),
         ("Object.defineProperty(foo, 'bar', { set(val) { return; } })", None),
         ("Reflect.defineProperty(foo, 'bar', { set(val) { if (val) { return; } } })", None),
-        (
-            "Object.defineProperties(foo, { bar: { set(val) { try { return; } catch(e){} } } })",
-            None,
-        ),
+        ("Object.defineProperties(foo, { bar: { set(val) { try { return; } catch(e){} } } })", None),
         ("Object.create(foo, { bar: { set: function(val) { return; } } })", None),
         ("x = { set(val) { return 1; } }", None),
         ("x = { foo: { set(val) { return 1; } } }", None),
@@ -138,10 +133,7 @@ fn test() {
         ("Object.create(foo, { set: function(val) { return 1; } })", None),
         ("Object.defineProperty(foo, { set: (val) => 1 })", None),
         ("Object.defineProperty(foo, 'bar', { set(val) { function foo() { return 1; } } })", None),
-        (
-            "Reflect.defineProperty(foo, 'bar', { set(val) { var foo = function() { return 1; } } })",
-            None,
-        ),
+        ("Reflect.defineProperty(foo, 'bar', { set(val) { var foo = function() { return 1; } } })", None),
         ("Object.defineProperties(foo, { bar: { set(val) { () => { return 1 }; } } })", None),
         ("Object.create(foo, { bar: { set: (val) => { (val) => 1; } } })", None),
         ("Object.defineProperty(foo, 'bar', 'baz', { set(val) { return 1; } })", None),
@@ -156,44 +148,20 @@ fn test() {
         ("Object.create({ bar: { set(val) { return 1; } } }, foo)", None),
         ("Object.DefineProperty(foo, 'bar', { set(val) { return 1; } })", None),
         ("Reflect.DefineProperty(foo, 'bar', { set(val) { if (val) { return 1; } } })", None),
-        (
-            "Object.DefineProperties(foo, { bar: { set(val) { try { return 1; } catch(e){} } } })",
-            None,
-        ),
+        ("Object.DefineProperties(foo, { bar: { set(val) { try { return 1; } catch(e){} } } })", None),
         ("Object.Create(foo, { bar: { set: function(val) { return 1; } } })", None),
         ("object.defineProperty(foo, 'bar', { set(val) { return 1; } })", None),
         ("reflect.defineProperty(foo, 'bar', { set(val) { if (val) { return 1; } } })", None),
-        (
-            "Reflect.defineProperties(foo, { bar: { set(val) { try { return 1; } catch(e){} } } })",
-            None,
-        ),
+        ("Reflect.defineProperties(foo, { bar: { set(val) { try { return 1; } catch(e){} } } })", None),
         ("object.create(foo, { bar: { set: function(val) { return 1; } } })", None),
         ("Reflect.defineProperty(foo, 'bar', { set(val) { if (val) { return 1; } } })", None),
-        (
-            "/* globals Object:off */ Object.defineProperty(foo, 'bar', { set(val) { return 1; } })",
-            None,
-        ),
-        (
-            "Object.defineProperties(foo, { bar: { set(val) { try { return 1; } catch(e){} } } })",
-            None,
-        ),
+        ("/* globals Object:off */ Object.defineProperty(foo, 'bar', { set(val) { return 1; } })", None),
+        ("Object.defineProperties(foo, { bar: { set(val) { try { return 1; } catch(e){} } } })", None),
         ("let Object; Object.defineProperty(foo, 'bar', { set(val) { return 1; } })", None),
-        (
-            "function f() { Reflect.defineProperty(foo, 'bar', { set(val) { if (val) { return 1; } } }); var Reflect;}",
-            None,
-        ),
-        (
-            "function f(Object) { Object.defineProperties(foo, { bar: { set(val) { try { return 1; } catch(e){} } } }) }",
-            None,
-        ),
-        (
-            "if (x) { const Object = getObject(); Object.create(foo, { bar: { set: function(val) { return 1; } } }) }",
-            None,
-        ),
-        (
-            "x = function Object() { Object.defineProperty(foo, 'bar', { set(val) { return 1; } }) }",
-            None,
-        ),
+        ("function f() { Reflect.defineProperty(foo, 'bar', { set(val) { if (val) { return 1; } } }); var Reflect;}", None),
+        ("function f(Object) { Object.defineProperties(foo, { bar: { set(val) { try { return 1; } catch(e){} } } }) }", None),
+        ("if (x) { const Object = getObject(); Object.create(foo, { bar: { set: function(val) { return 1; } } }) }", None),
+        ("x = function Object() { Object.defineProperty(foo, 'bar', { set(val) { return 1; } }) }", None),
     ];
 
     let fail = vec![
@@ -216,23 +184,11 @@ fn test() {
         ("class A { set a(val) { return 1; } set b(val) { return 1; } }", None),
         ("(class { set a(val) { return 1; } static set b(val) { return 1; } })", None),
         ("({ set a(val) { if(val) { return 1; } else { return 2 }; } })", None),
-        (
-            "class A { set a(val) { switch(val) { case 1: return x; case 2: return y; default: return z } } }",
-            None,
-        ),
-        (
-            "(class { static set a(val) { if (val > 0) { this._val = val; return val; } return false; } })",
-            None,
-        ),
+        ("class A { set a(val) { switch(val) { case 1: return x; case 2: return y; default: return z } } }", None),
+        ("(class { static set a(val) { if (val > 0) { this._val = val; return val; } return false; } })", None),
         ("({ set a(val) { if(val) { return 1; } else { return; }; } })", None),
-        (
-            "class A { set a(val) { switch(val) { case 1: return x; case 2: return; default: return z } } }",
-            None,
-        ),
-        (
-            "(class { static set a(val) { if (val > 0) { this._val = val; return; } return false; } })",
-            None,
-        ),
+        ("class A { set a(val) { switch(val) { case 1: return x; case 2: return; default: return z } } }", None),
+        ("(class { static set a(val) { if (val > 0) { this._val = val; return; } return false; } })", None),
         ("({ set a(val) { function b(){} return b(); } })", None),
         ("class A { set a(val) { return () => {}; } }", None),
         ("(class { set a(val) { function b(){ return 1; } return 2; } })", None),
diff --git a/crates/oxc_linter/src/rules/eslint/no_shadow_restricted_names.rs b/crates/oxc_linter/src/rules/eslint/no_shadow_restricted_names.rs
index 7c4a9153a816..982f927d6846 100644
--- a/crates/oxc_linter/src/rules/eslint/no_shadow_restricted_names.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_shadow_restricted_names.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, globals::PRE_DEFINE_VAR, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-shadow-restricted-names): Shadowing of global properties such as 'undefined' is not allowed.")]
-#[diagnostic(severity(warning), help("Shadowing of global properties '{0}'."))]
-struct NoShadowRestrictedNamesDiagnostic(CompactStr, #[label] pub Span);
+fn no_shadow_restricted_names_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-shadow-restricted-names): Shadowing of global properties such as 'undefined' is not allowed.")
+        .with_help(format!("Shadowing of global properties '{x0}'."))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoShadowRestrictedNames;
@@ -41,7 +40,7 @@ declare_oxc_lint!(
 #[inline]
 fn check_and_diagnostic(s: &str, span: Span, ctx: &LintContext) {
     if PRE_DEFINE_VAR.contains_key(s) {
-        ctx.diagnostic(NoShadowRestrictedNamesDiagnostic(s.into(), span));
+        ctx.diagnostic(no_shadow_restricted_names_diagnostic(s, span));
     }
 }
 
@@ -125,23 +124,32 @@ fn test() {
         ("function Infinity(Infinity) { var Infinity; !function Infinity(Infinity) { try {} catch(Infinity) {} }; }", None),
         ("function arguments(arguments) { var arguments; !function arguments(arguments) { try {} catch(arguments) {} }; }", None),
         ("function eval(eval) { var eval; !function eval(eval) { try {} catch(eval) {} }; }", None),
-        ("var eval = (eval) => { var eval; !function eval(eval) { try {} catch(eval) {} }; }", Some(json!({
-            "parserOptions": {
-                "ecmaVersion": 6
-            }
-        }))),
-        ("var {undefined} = obj; var {a: undefined} = obj; var {a: {b: {undefined}}} = obj; var {a, ...undefined} = obj;", Some(json!({
-            "parserOptions": {
-                "ecmaVersion": 9
-            }
-        }))),
+        (
+            "var eval = (eval) => { var eval; !function eval(eval) { try {} catch(eval) {} }; }",
+            Some(json!({
+                "parserOptions": {
+                    "ecmaVersion": 6
+                }
+            })),
+        ),
+        (
+            "var {undefined} = obj; var {a: undefined} = obj; var {a: {b: {undefined}}} = obj; var {a, ...undefined} = obj;",
+            Some(json!({
+                "parserOptions": {
+                    "ecmaVersion": 9
+                }
+            })),
+        ),
         ("var normal, undefined; undefined = 5;", None),
         ("try {} catch(undefined: undefined) {}", None),
-        ("var [undefined] = [1]", Some(json!({
-            "parserOptions": {
-                "ecmaVersion": 6
-            }
-        }))),
+        (
+            "var [undefined] = [1]",
+            Some(json!({
+                "parserOptions": {
+                    "ecmaVersion": 6
+                }
+            })),
+        ),
         ("class undefined { }", None),
         ("class foo { undefined(undefined) { } }", None),
         ("class foo { #undefined(undefined) { } }", None),
diff --git a/crates/oxc_linter/src/rules/eslint/no_sparse_arrays.rs b/crates/oxc_linter/src/rules/eslint/no_sparse_arrays.rs
index 8baf3acecb76..a5a61a0b6eeb 100644
--- a/crates/oxc_linter/src/rules/eslint/no_sparse_arrays.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_sparse_arrays.rs
@@ -1,6 +1,5 @@
-use miette::{miette, LabeledSpan};
 use oxc_ast::{ast::ArrayExpressionElement, AstKind};
-use oxc_diagnostics::miette::{self, Severity};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
 use oxc_macros::declare_oxc_lint;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
@@ -46,12 +45,13 @@ impl Rule for NoSparseArrays {
 
             if !violations.is_empty() {
                 if violations.len() < 10 {
-                    ctx.diagnostic(miette!(
-                        severity = Severity::Warning,
-                        labels = violations,
-                        help = "remove the comma or insert `undefined`",
-                        "eslint(no-sparse-arrays): Unexpected comma in middle of array"
-                    ));
+                    ctx.diagnostic(
+                        OxcDiagnostic::warning(
+                            "eslint(no-sparse-arrays): Unexpected comma in middle of array",
+                        )
+                        .with_help("remove the comma or insert `undefined`")
+                        .with_labels(violations),
+                    );
                 } else {
                     let span = if (array_expr.span.end - array_expr.span.start) < 50 {
                         LabeledSpan::at(array_expr.span, "the array here")
@@ -62,13 +62,14 @@ impl Rule for NoSparseArrays {
                         )
                     };
 
-                    ctx.diagnostic(miette!(
-                        severity = Severity::Warning,
-                        labels = vec![span],
-                        help = "remove the comma or insert `undefined`",
-                        "eslint(no-sparse-arrays): {} unexpected commas in middle of array",
-                        violations.len()
-                    ));
+                    ctx.diagnostic(
+                        OxcDiagnostic::warning(format!(
+                            "eslint(no-sparse-arrays): {} unexpected commas in middle of array",
+                            violations.len()
+                        ))
+                        .with_help("remove the comma or insert `undefined`")
+                        .with_label(span),
+                    );
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/eslint/no_template_curly_in_string.rs b/crates/oxc_linter/src/rules/eslint/no_template_curly_in_string.rs
index 0bb530197f9b..bc81ae265c59 100644
--- a/crates/oxc_linter/src/rules/eslint/no_template_curly_in_string.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_template_curly_in_string.rs
@@ -1,20 +1,18 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-template-curly-in-string): Unexpected template string expression")]
-#[diagnostic(
-    severity(warning),
-    help("Disallow template literal placeholder syntax in regular strings")
-)]
-struct NoTemplateCurlyInStringDiagnostic(#[label] pub Span);
+fn no_template_curly_in_string_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(no-template-curly-in-string): Unexpected template string expression",
+    )
+    .with_help("Disallow template literal placeholder syntax in regular strings")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoTemplateCurlyInString;
@@ -64,7 +62,7 @@ impl Rule for NoTemplateCurlyInString {
                         .expect("Conversion from usize to u32 failed for match_start");
                     let match_end = u32::try_from(end_index + 1)
                         .expect("Conversion from usize to u32 failed for match_end");
-                    ctx.diagnostic(NoTemplateCurlyInStringDiagnostic(Span::new(
+                    ctx.diagnostic(no_template_curly_in_string_diagnostic(Span::new(
                         literal_span_start + match_start,
                         literal_span_start + match_end,
                     )));
diff --git a/crates/oxc_linter/src/rules/eslint/no_ternary.rs b/crates/oxc_linter/src/rules/eslint/no_ternary.rs
index af5c66ee835f..2003bcb037fd 100644
--- a/crates/oxc_linter/src/rules/eslint/no_ternary.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_ternary.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-ternary): Unexpected use of ternary expression")]
-#[diagnostic(severity(warning), help("Do not use the ternary expression."))]
-struct NoTernaryDiagnostic(#[label] pub Span);
+fn no_ternary_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-ternary): Unexpected use of ternary expression")
+        .with_help("Do not use the ternary expression.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoTernary;
@@ -38,7 +37,7 @@ declare_oxc_lint!(
 impl Rule for NoTernary {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::ConditionalExpression(cond_expr) = node.kind() {
-            ctx.diagnostic(NoTernaryDiagnostic(Span::new(
+            ctx.diagnostic(no_ternary_diagnostic(Span::new(
                 cond_expr.span.start,
                 cond_expr.span.end,
             )));
diff --git a/crates/oxc_linter/src/rules/eslint/no_this_before_super.rs b/crates/oxc_linter/src/rules/eslint/no_this_before_super.rs
index b6dcfe79a3e5..f079237ae118 100644
--- a/crates/oxc_linter/src/rules/eslint/no_this_before_super.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_this_before_super.rs
@@ -1,13 +1,11 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use std::collections::{HashMap, HashSet};
 
 use oxc_ast::{
     ast::{Expression, MethodDefinitionKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{
     petgraph::stable_graph::NodeIndex, pg::neighbors_filtered_by_edge_weight, AstNodeId, EdgeType,
@@ -16,10 +14,11 @@ use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-this-before-super): Expected to always call super() before this/super property access.")]
-#[diagnostic(severity(warning), help("Call super() before this/super property access."))]
-struct NoThisBeforeSuperDiagnostic(#[label] pub Span);
+fn no_this_before_super_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-this-before-super): Expected to always call super() before this/super property access.")
+        .with_help("Call super() before this/super property access.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoThisBeforeSuper;
@@ -138,7 +137,7 @@ impl Rule for NoThisBeforeSuper {
                 // so the unwrap() is safe here. The parent node is the
                 // AstKind::MethodDefinition for `constructor`.
                 let parent_span = ctx.nodes().parent_node(node.id()).unwrap().kind().span();
-                ctx.diagnostic(NoThisBeforeSuperDiagnostic(parent_span));
+                ctx.diagnostic(no_this_before_super_diagnostic(parent_span));
             }
         }
     }
@@ -182,7 +181,6 @@ fn test() {
         ("class A { constructor() { this.b(); } }", None),
         ("class A extends null { }", None),
         ("class A extends null { constructor() { } }", None),
-
         // allows `this`/`super` after `super()`.
         ("class A extends B { }", None),
         ("class A extends B { constructor() { super(); } }", None),
@@ -194,31 +192,25 @@ fn test() {
         ("class A extends B { constructor() { foo += super().a; this.c(); } }", None),
         ("class A extends B { constructor() { foo |= super().a; this.c(); } }", None),
         ("class A extends B { constructor() { foo &= super().a; this.c(); } }", None),
-
         // allows `this`/`super` in nested executable scopes, even if before `super()`.
         ("class A extends B { constructor() { class B extends C { constructor() { super(); this.d = 0; } } super(); } }", None),
         ("class A extends B { constructor() { var B = class extends C { constructor() { super(); this.d = 0; } }; super(); } }", None),
         ("class A extends B { constructor() { function c() { this.d(); } super(); } }", None),
         ("class A extends B { constructor() { var c = function c() { this.d(); }; super(); } }", None),
         ("class A extends B { constructor() { var c = () => this.d(); super(); } }", None),
-
         // ignores out of constructors.
         ("class A { b() { this.c = 0; } }", None),
         ("class A extends B { c() { this.d = 0; } }", None),
         ("function a() { this.b = 0; }", None),
-
         // multi code path.
         ("class A extends B { constructor() { if (a) { super(); this.a(); } else { super(); this.b(); } } }", None),
         ("class A extends B { constructor() { if (a) super(); else super(); this.a(); } }", None),
         ("class A extends B { constructor() { try { super(); } finally {} this.a(); } }", None),
-
         // https://github.com/eslint/eslint/issues/5261
         ("class A extends B { constructor(a) { super(); for (const b of a) { this.a(); } } }", None),
         ("class A extends B { constructor(a) { for (const b of a) { foo(b); } super(); } }", None),
-
         // https://github.com/eslint/eslint/issues/5319
         ("class A extends B { constructor(a) { super(); this.a = a && function(){} && this.foo; } }", None),
-
         // https://github.com/eslint/eslint/issues/5394
         (
             r"class A extends Object {
@@ -227,14 +219,15 @@ fn test() {
                     for (let i = 0; i < 0; i++);
                     this;
                 }
-            }", None),
-
+            }",
+            None,
+        ),
         // https://github.com/eslint/eslint/issues/5894
         ("class A { constructor() { return; this; } }", None),
         ("class A extends B { constructor() { return; this; } }", None),
-
         // https://github.com/eslint/eslint/issues/8848
-        (r"
+        (
+            r"
             class A extends B {
                 constructor(props) {
                     super(props);
@@ -247,13 +240,14 @@ fn test() {
                     }
                 }
             }
-        ", None),
-
+        ",
+            None,
+        ),
         // Class field initializers are always evaluated after `super()`.
         ("class C { field = this.toString(); }", None),
         ("class C extends B { field = this.foo(); }", None),
         ("class C extends B { field = this.foo(); constructor() { super(); } }", None),
-        ("class C extends B { field = this.foo(); constructor() { } }", None) // < in this case, initializers are never evaluated.
+        ("class C extends B { field = this.foo(); constructor() { } }", None), // < in this case, initializers are never evaluated.
     ];
 
     let fail = vec![
@@ -280,7 +274,8 @@ fn test() {
         ("class A extends B { constructor() { foo ||= super().a; this.c(); } }", None),
         ("class A extends B { constructor() { foo ??= super().a; this.c(); } }", None),
         ("class A extends B { constructor() { if (foo) { if (bar) { } super(); } this.a(); }}", None),
-        ("class A extends B {
+        (
+            "class A extends B {
                 constructor() {
                     if (foo) {
                     } else {
@@ -288,8 +283,11 @@ fn test() {
                     }
                     this.a();
                 }
-            }", None),
-        ("class A extends B {
+            }",
+            None,
+        ),
+        (
+            "class A extends B {
                 constructor() {
                     try {
                         call();
@@ -297,24 +295,33 @@ fn test() {
                         this.a();
                     }
                 }
-            }", None),
-        ("class A extends B {
+            }",
+            None,
+        ),
+        (
+            "class A extends B {
                 constructor() {
                     while (foo) {
                         super();
                     }
                     this.a();
                 }
-            }", None),
-        ("class A extends B {
+            }",
+            None,
+        ),
+        (
+            "class A extends B {
                 constructor() {
                     while (foo) {
                         this.a();
                         super();
                     }
                 }
-            }", None),
-        ("class A extends B {
+            }",
+            None,
+        ),
+        (
+            "class A extends B {
                 constructor() {
                     while (foo) {
                         if (init) {
@@ -323,7 +330,9 @@ fn test() {
                         }
                     }
                 }
-            }", None),
+            }",
+            None,
+        ),
     ];
 
     Tester::new(NoThisBeforeSuper::NAME, pass, fail).test_and_snapshot();
diff --git a/crates/oxc_linter/src/rules/eslint/no_undef.rs b/crates/oxc_linter/src/rules/eslint/no_undef.rs
index 996cfd7ccefe..8791f036c757 100644
--- a/crates/oxc_linter/src/rules/eslint/no_undef.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_undef.rs
@@ -1,18 +1,17 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 use oxc_syntax::operator::UnaryOperator;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-undef): Disallow the use of undeclared variables.")]
-#[diagnostic(severity(warning), help("'{0}' is not defined."))]
-struct NoUndefDiagnostic(CompactStr, #[label] pub Span);
+fn no_undef_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-undef): Disallow the use of undeclared variables.")
+        .with_help(format!("'{x0}' is not defined."))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUndef {
@@ -69,7 +68,7 @@ impl Rule for NoUndef {
                     continue;
                 }
 
-                ctx.diagnostic(NoUndefDiagnostic(name.clone(), reference.span()));
+                ctx.diagnostic(no_undef_diagnostic(name, reference.span()));
             }
         }
     }
@@ -157,7 +156,7 @@ fn test() {
         "class C { static { let a; a; } }",
         "class C { static { a; let a; } }",
         "class C { static { function a() {} a; } }",
-        "class C { static { a; function a() {} } }"
+        "class C { static { a; function a() {} } }",
     ];
 
     let fail = vec![
diff --git a/crates/oxc_linter/src/rules/eslint/no_unsafe_finally.rs b/crates/oxc_linter/src/rules/eslint/no_unsafe_finally.rs
index 1ce28c51618d..944b4ed399ca 100644
--- a/crates/oxc_linter/src/rules/eslint/no_unsafe_finally.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_unsafe_finally.rs
@@ -2,22 +2,18 @@ use oxc_ast::{
     ast::{BreakStatement, ContinueStatement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-unsafe-finally): Unsafe finally block")]
-#[diagnostic(
-    severity(warning),
-    help("Control flow inside try or catch blocks will be overwritten by this statement")
-)]
-struct NoUnsafeFinallyDiagnostic(#[label] Span);
+fn no_unsafe_finally_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-unsafe-finally): Unsafe finally block")
+        .with_help("Control flow inside try or catch blocks will be overwritten by this statement")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnsafeFinally;
@@ -92,7 +88,7 @@ impl Rule for NoUnsafeFinally {
                 if label_name.is_some() && label_inside {
                     break;
                 }
-                ctx.diagnostic(NoUnsafeFinallyDiagnostic(node.kind().span()));
+                ctx.diagnostic(no_unsafe_finally_diagnostic(node.kind().span()));
                 return;
             }
         }
@@ -124,100 +120,37 @@ fn test() {
     use crate::tester::Tester;
 
     let pass = vec![
-        (
-            "var foo = function() {\n try { \n return 1; \n } catch(err) { \n return 2; \n } finally { \n console.log('hola!') \n } \n }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1 } catch(err) { return 2 } finally { console.log('hola!') } }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1 } catch(err) { return 2 } finally { function a(x) { return x } } }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1 } catch(err) { return 2 } finally { var a = function(x) { if(!x) { throw new Error() } } } }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1 } catch(err) { return 2 } finally { var a = function(x) { while(true) { if(x) { break } else { continue } } } } }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1 } catch(err) { return 2 } finally { var a = function(x) { label: while(true) { if(x) { break label; } else { continue } } } } }",
-            None,
-        ),
+        ("var foo = function() {\n try { \n return 1; \n } catch(err) { \n return 2; \n } finally { \n console.log('hola!') \n } \n }", None),
+        ("var foo = function() { try { return 1 } catch(err) { return 2 } finally { console.log('hola!') } }", None),
+        ("var foo = function() { try { return 1 } catch(err) { return 2 } finally { function a(x) { return x } } }", None),
+        ("var foo = function() { try { return 1 } catch(err) { return 2 } finally { var a = function(x) { if(!x) { throw new Error() } } } }", None),
+        ("var foo = function() { try { return 1 } catch(err) { return 2 } finally { var a = function(x) { while(true) { if(x) { break } else { continue } } } } }", None),
+        ("var foo = function() { try { return 1 } catch(err) { return 2 } finally { var a = function(x) { label: while(true) { if(x) { break label; } else { continue } } } } }", None),
         ("var foo = function() { try {} finally { while (true) break; } }", None),
         ("var foo = function() { try {} finally { while (true) continue; } }", None),
         ("var foo = function() { try {} finally { switch (true) { case true: break; } } }", None),
         ("var foo = function() { try {} finally { do { break; } while (true) } }", None),
-        (
-            "var foo = function() { try { return 1; } catch(err) { return 2; } finally { var bar = () => { throw new Error(); }; } };",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1; } catch(err) { return 2 } finally { (x) => x } }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1; } finally { class bar { constructor() {} static ehm() { return 'Hola!'; } } } };",
-            None,
-        ),
+        ("var foo = function() { try { return 1; } catch(err) { return 2; } finally { var bar = () => { throw new Error(); }; } };", None),
+        ("var foo = function() { try { return 1; } catch(err) { return 2 } finally { (x) => x } }", None),
+        ("var foo = function() { try { return 1; } finally { class bar { constructor() {} static ehm() { return 'Hola!'; } } } };", None),
     ];
 
     let fail = vec![
-        (
-            "var foo = function() { \n try { \n return 1; \n } catch(err) { \n return 2; \n } finally { \n return 3; \n } \n }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1 } catch(err) { return 2 } finally { if(true) { return 3 } else { return 2 } } }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1 } catch(err) { return 2 } finally { return 3 } }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1 } catch(err) { return 2 } finally { return function(x) { return y } } }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1 } catch(err) { return 2 } finally { return { x: function(c) { return c } } } }",
-            None,
-        ),
-        (
-            "var foo = function() { try { return 1 } catch(err) { return 2 } finally { throw new Error() } }",
-            None,
-        ),
-        (
-            "var foo = function() { try { foo(); } finally { try { bar(); } finally { return; } } };",
-            None,
-        ),
-        (
-            "var foo = function() { label: try { return 0; } finally { break label; } return 1; }",
-            None,
-        ),
-        (
-            "var foo = function() { \n a: try { \n return 1; \n } catch(err) { \n return 2; \n } finally { \n break a; \n } \n }",
-            None,
-        ),
+        ("var foo = function() { \n try { \n return 1; \n } catch(err) { \n return 2; \n } finally { \n return 3; \n } \n }", None),
+        ("var foo = function() { try { return 1 } catch(err) { return 2 } finally { if(true) { return 3 } else { return 2 } } }", None),
+        ("var foo = function() { try { return 1 } catch(err) { return 2 } finally { return 3 } }", None),
+        ("var foo = function() { try { return 1 } catch(err) { return 2 } finally { return function(x) { return y } } }", None),
+        ("var foo = function() { try { return 1 } catch(err) { return 2 } finally { return { x: function(c) { return c } } } }", None),
+        ("var foo = function() { try { return 1 } catch(err) { return 2 } finally { throw new Error() } }", None),
+        ("var foo = function() { try { foo(); } finally { try { bar(); } finally { return; } } };", None),
+        ("var foo = function() { label: try { return 0; } finally { break label; } return 1; }", None),
+        ("var foo = function() { \n a: try { \n return 1; \n } catch(err) { \n return 2; \n } finally { \n break a; \n } \n }", None),
         ("var foo = function() { while (true) try {} finally { break; } }", None),
         ("var foo = function() { while (true) try {} finally { continue; } }", None),
         ("var foo = function() { switch (true) { case true: try {} finally { break; } } }", None),
-        (
-            "var foo = function() { a: while (true) try {} finally { switch (true) { case true: break a; } } }",
-            None,
-        ),
-        (
-            "var foo = function() { a: while (true) try {} finally { switch (true) { case true: continue; } } }",
-            None,
-        ),
-        (
-            "var foo = function() { a: switch (true) { case true: try {} finally { switch (true) { case true: break a; } } } }",
-            None,
-        ),
+        ("var foo = function() { a: while (true) try {} finally { switch (true) { case true: break a; } } }", None),
+        ("var foo = function() { a: while (true) try {} finally { switch (true) { case true: continue; } } }", None),
+        ("var foo = function() { a: switch (true) { case true: try {} finally { switch (true) { case true: break a; } } } }", None),
     ];
 
     Tester::new(NoUnsafeFinally::NAME, pass, fail).test_and_snapshot();
diff --git a/crates/oxc_linter/src/rules/eslint/no_unsafe_negation.rs b/crates/oxc_linter/src/rules/eslint/no_unsafe_negation.rs
index 12024952bc29..ac640272f12b 100644
--- a/crates/oxc_linter/src/rules/eslint/no_unsafe_negation.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_unsafe_negation.rs
@@ -2,25 +2,19 @@ use oxc_ast::{
     ast::{BinaryExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{BinaryOperator, UnaryOperator};
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("Unexpected logical not in the left hand side of '{0}' operator")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "use parenthesis to express the negation of the whole boolean expression, as '!' binds more closely than '{0}'"
-    )
-)]
-struct NoUnsafeNegationDiagnostic(&'static str, #[label] pub Span);
+fn no_unsafe_negation_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("Unexpected logical not in the left hand side of '{x0}' operator"))
+        .with_help(format!("use parenthesis to express the negation of the whole boolean expression, as '!' binds more closely than '{x0}'"))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnsafeNegation {
@@ -84,7 +78,7 @@ impl NoUnsafeNegation {
     fn report_with_fix(expr: &BinaryExpression, ctx: &LintContext<'_>) {
         use oxc_codegen::{Context, Gen};
         // Diagnostic points at the unexpected negation
-        let diagnostic = NoUnsafeNegationDiagnostic(expr.operator.as_str(), expr.left.span());
+        let diagnostic = no_unsafe_negation_diagnostic(expr.operator.as_str(), expr.left.span());
 
         let fix_producer = || {
             // modify `!a instance of B` to `!(a instanceof B)`
diff --git a/crates/oxc_linter/src/rules/eslint/no_unsafe_optional_chaining.rs b/crates/oxc_linter/src/rules/eslint/no_unsafe_optional_chaining.rs
index 212cde835b88..9eb17e9c83ee 100644
--- a/crates/oxc_linter/src/rules/eslint/no_unsafe_optional_chaining.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_unsafe_optional_chaining.rs
@@ -2,28 +2,27 @@ use oxc_ast::{
     ast::{match_assignment_target_pattern, Argument, AssignmentTarget, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::LogicalOperator;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-unsafe-optional-chaining): Unsafe usage of optional chaining")]
-#[diagnostic(
-    severity(warning),
-    help("If this short-circuits with 'undefined' the evaluation will throw TypeError")
-)]
-struct NoUnsafeOptionalChainingDiagnostic(#[label] pub Span);
+fn no_unsafe_optional_chaining_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-unsafe-optional-chaining): Unsafe usage of optional chaining")
+        .with_help("If this short-circuits with 'undefined' the evaluation will throw TypeError")
+        .with_labels([span0.into()])
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-unsafe-optional-chaining): Unsafe arithmetic operation on optional chaining")]
-#[diagnostic(severity(warning), help("This can result in NaN."))]
-struct NoUnsafeArithmeticDiagnostic(#[label] pub Span);
+fn no_unsafe_arithmetic_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(no-unsafe-optional-chaining): Unsafe arithmetic operation on optional chaining",
+    )
+    .with_help("This can result in NaN.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnsafeOptionalChaining {
@@ -179,10 +178,10 @@ impl NoUnsafeOptionalChaining {
             Expression::ChainExpression(expr) => {
                 match error_type {
                     ErrorType::Usage => {
-                        ctx.diagnostic(NoUnsafeOptionalChainingDiagnostic(expr.span));
+                        ctx.diagnostic(no_unsafe_optional_chaining_diagnostic(expr.span));
                     }
                     ErrorType::Arithmetic => {
-                        ctx.diagnostic(NoUnsafeArithmeticDiagnostic(expr.span));
+                        ctx.diagnostic(no_unsafe_arithmetic_diagnostic(expr.span));
                     }
                 };
             }
@@ -232,10 +231,7 @@ fn test() {
         ("({foo: obj.bar = obj?.baz} = obj);", None),
         ("(foo?.bar, bar)();", None),
         ("(foo?.bar ? baz : qux)();", None),
-        (
-            "\n        async function func() {\n          await obj?.foo();\n          await obj?.foo?.();\n          (await obj?.foo)?.();\n          (await obj?.foo)?.bar;\n          await bar?.baz;\n          await (foo ?? obj?.foo.baz);\n          (await bar?.baz ?? bar).baz;\n          (await bar?.baz ?? await bar).baz;\n          await (foo?.bar ? baz : qux);\n        }\n        ",
-            None,
-        ),
+        ("\n        async function func() {\n          await obj?.foo();\n          await obj?.foo?.();\n          (await obj?.foo)?.();\n          (await obj?.foo)?.bar;\n          await bar?.baz;\n          await (foo ?? obj?.foo.baz);\n          (await bar?.baz ?? bar).baz;\n          (await bar?.baz ?? await bar).baz;\n          await (foo?.bar ? baz : qux);\n        }\n        ", None),
         ("(obj?.foo ?? bar?.baz ?? qux)();", None),
         ("((obj?.foo ?? bar?.baz) || qux)();", None),
         ("((obj?.foo || bar?.baz) || qux)();", None),
@@ -254,10 +250,7 @@ fn test() {
         ("bar **= obj?.foo;", None),
         ("bar *= obj?.boo", None),
         ("bar /= obj?.boo", None),
-        (
-            "async function func() {\n            await obj?.foo + await obj?.bar;\n            await obj?.foo - await obj?.bar;\n            await obj?.foo * await obj?.bar;\n            +await obj?.foo;\n            -await obj?.foo;\n            bar += await obj?.foo;\n            bar -= await obj?.foo;\n            bar %= await obj?.foo;\n            bar **= await obj?.foo;\n            bar *= await obj?.boo;\n            bar /= await obj?.boo;\n        }\n        ",
-            None,
-        ),
+        ("async function func() {\n            await obj?.foo + await obj?.bar;\n            await obj?.foo - await obj?.bar;\n            await obj?.foo * await obj?.bar;\n            +await obj?.foo;\n            -await obj?.foo;\n            bar += await obj?.foo;\n            bar -= await obj?.foo;\n            bar %= await obj?.foo;\n            bar **= await obj?.foo;\n            bar *= await obj?.boo;\n            bar /= await obj?.boo;\n        }\n        ", None),
         ("obj?.foo - bar;", Some(serde_json::json!([{}]))),
         (
             "obj?.foo - bar;",
diff --git a/crates/oxc_linter/src/rules/eslint/no_unused_labels.rs b/crates/oxc_linter/src/rules/eslint/no_unused_labels.rs
index 4cc32d2945fe..f6b0bb3ba4a8 100644
--- a/crates/oxc_linter/src/rules/eslint/no_unused_labels.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_unused_labels.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-unused-labels): Disallow unused labels")]
-#[diagnostic(severity(warning), help("'{0}:' is defined but never used."))]
-struct NoUnusedLabelsDiagnostic(CompactStr, #[label] pub Span);
+fn no_unused_labels_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-unused-labels): Disallow unused labels")
+        .with_help(format!("'{x0}:' is defined but never used."))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnusedLabels;
@@ -51,7 +50,7 @@ impl Rule for NoUnusedLabels {
                 // TODO: Ignore fix where comments exist between label and statement
                 // e.g. A: /* Comment */ function foo(){}
                 ctx.diagnostic_with_fix(
-                    NoUnusedLabelsDiagnostic(stmt.label.name.to_compact_str(), stmt.label.span),
+                    no_unused_labels_diagnostic(stmt.label.name.as_str(), stmt.label.span),
                     || Fix::delete(stmt.label.span),
                 );
             }
@@ -69,10 +68,7 @@ fn test() {
         ("A: if (a) { foo(); if (b) break A; bar(); }", None),
         ("A: for (var i = 0; i < 10; ++i) { foo(); if (a) break A; bar(); }", None),
         ("A: for (var i = 0; i < 10; ++i) { foo(); if (a) continue A; bar(); }", None),
-        (
-            "A: { B: break B; C: for (var i = 0; i < 10; ++i) { foo(); if (a) break A; if (c) continue C; bar(); } }",
-            None,
-        ),
+        ("A: { B: break B; C: for (var i = 0; i < 10; ++i) { foo(); if (a) break A; if (c) continue C; bar(); } }", None),
         ("A: { var A = 0; console.log(A); break A; console.log(A); }", None),
     ];
 
diff --git a/crates/oxc_linter/src/rules/eslint/no_unused_private_class_members.rs b/crates/oxc_linter/src/rules/eslint/no_unused_private_class_members.rs
index 12677949d5e4..f291c92d3b92 100644
--- a/crates/oxc_linter/src/rules/eslint/no_unused_private_class_members.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_unused_private_class_members.rs
@@ -1,20 +1,20 @@
 use itertools::Itertools;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{AstNode, AstNodeId, AstNodes};
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 use oxc_syntax::class::ElementKind;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-unused-private-class-members): '{0}' is defined but never used.")]
-#[diagnostic(severity(warning))]
-struct NoUnusedPrivateClassMembersDiagnostic(CompactStr, #[label] pub Span);
+fn no_unused_private_class_members_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(no-unused-private-class-members): '{x0}' is defined but never used."
+    ))
+    .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnusedPrivateClassMembers;
@@ -106,8 +106,8 @@ impl Rule for NoUnusedPrivateClassMembers {
                             && ident.element_ids.contains(&element_id)
                     })
                 {
-                    ctx.diagnostic(NoUnusedPrivateClassMembersDiagnostic(
-                        element.name.clone(),
+                    ctx.diagnostic(no_unused_private_class_members_diagnostic(
+                        &element.name,
                         element.span,
                     ));
                 }
diff --git a/crates/oxc_linter/src/rules/eslint/no_useless_catch.rs b/crates/oxc_linter/src/rules/eslint/no_useless_catch.rs
index f7837ccbdf7e..1b63292e5e26 100644
--- a/crates/oxc_linter/src/rules/eslint/no_useless_catch.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_useless_catch.rs
@@ -2,30 +2,26 @@ use oxc_ast::{
     ast::{BindingPatternKind, Expression, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-useless-catch): Unnecessary try/catch wrapper")]
-#[diagnostic(severity(warning))]
-struct NoUselessCatchDiagnostic(
-    #[label("is caught here")] pub Span,
-    #[label("and re-thrown here")] pub Span,
-);
+fn no_useless_catch_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-useless-catch): Unnecessary try/catch wrapper").with_labels([
+        LabeledSpan::new_with_span(Some("is caught here".into()), span0),
+        LabeledSpan::new_with_span(Some("and re-thrown here".into()), span1),
+    ])
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-useless-catch): Unnecessary catch clause")]
-#[diagnostic(severity(warning))]
-struct NoUselessCatchFinalizerDiagnostic(
-    #[label("is caught here")] pub Span,
-    #[label("and re-thrown here")] pub Span,
-);
+fn no_useless_catch_finalizer_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-useless-catch): Unnecessary catch clause").with_labels([
+        LabeledSpan::new_with_span(Some("is caught here".into()), span0),
+        LabeledSpan::new_with_span(Some("and re-thrown here".into()), span1),
+    ])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUselessCatch;
@@ -56,8 +52,12 @@ declare_oxc_lint!(
 
 impl Rule for NoUselessCatch {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::TryStatement(try_stmt) = node.kind() else { return };
-        let Some(catch_clause) = &try_stmt.handler else { return };
+        let AstKind::TryStatement(try_stmt) = node.kind() else {
+            return;
+        };
+        let Some(catch_clause) = &try_stmt.handler else {
+            return;
+        };
         let Some(BindingPatternKind::BindingIdentifier(binding_ident)) =
             catch_clause.param.as_ref().map(|param| &param.pattern.kind)
         else {
@@ -66,15 +66,17 @@ impl Rule for NoUselessCatch {
         let Some(Statement::ThrowStatement(throw_stmt)) = catch_clause.body.body.first() else {
             return;
         };
-        let Expression::Identifier(throw_ident) = &throw_stmt.argument else { return };
+        let Expression::Identifier(throw_ident) = &throw_stmt.argument else {
+            return;
+        };
         if binding_ident.name == throw_ident.name {
             if try_stmt.finalizer.is_some() {
-                ctx.diagnostic(NoUselessCatchFinalizerDiagnostic(
+                ctx.diagnostic(no_useless_catch_finalizer_diagnostic(
                     binding_ident.span,
                     throw_stmt.span,
                 ));
             } else {
-                ctx.diagnostic(NoUselessCatchDiagnostic(binding_ident.span, throw_stmt.span));
+                ctx.diagnostic(no_useless_catch_diagnostic(binding_ident.span, throw_stmt.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/eslint/no_useless_escape.rs b/crates/oxc_linter/src/rules/eslint/no_useless_escape.rs
index 46896570d4f4..786bc8f60f49 100644
--- a/crates/oxc_linter/src/rules/eslint/no_useless_escape.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_useless_escape.rs
@@ -1,20 +1,19 @@
 use memchr::memmem;
+use oxc_diagnostics::OxcDiagnostic;
 
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNodeId;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-useless-escape): Unnecessary escape character {0:?}")]
-#[diagnostic(severity(warning))]
-struct NoUselessEscapeDiagnostic(char, #[label] pub Span);
+fn no_useless_escape_diagnostic(x0: char, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint(no-useless-escape): Unnecessary escape character {x0:?}"
+    ))
+    .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUselessEscape;
@@ -87,7 +86,7 @@ fn check(ctx: &LintContext<'_>, node_id: AstNodeId, start: u32, offsets: &[usize
 
         if !is_within_jsx_attribute_item(node_id, ctx) {
             let span = Span::new(offset - 1, offset + len);
-            ctx.diagnostic_with_fix(NoUselessEscapeDiagnostic(c, span), || {
+            ctx.diagnostic_with_fix(no_useless_escape_diagnostic(c, span), || {
                 Fix::new(c.to_string(), span)
             });
         }
diff --git a/crates/oxc_linter/src/rules/eslint/no_useless_rename.rs b/crates/oxc_linter/src/rules/eslint/no_useless_rename.rs
index d8241bb31a6a..4710c808d7b8 100644
--- a/crates/oxc_linter/src/rules/eslint/no_useless_rename.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_useless_rename.rs
@@ -2,20 +2,19 @@ use oxc_ast::{
     ast::{AssignmentTarget, AssignmentTargetProperty, BindingPatternKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 use oxc_span::GetSpan;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-useless-rename): Disallow renaming import, export, and destructured assignments to the same name")]
-#[diagnostic(severity(warning), help("Either remove the renaming or rename the variable."))]
-struct NoUselessRenameDiagnostic(#[label] pub Span);
+fn no_useless_rename_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-useless-rename): Disallow renaming import, export, and destructured assignments to the same name")
+        .with_help("Either remove the renaming or rename the variable.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUselessRename(Box<NoUselessRenameConfig>);
@@ -93,7 +92,9 @@ impl Rule for NoUselessRename {
                         continue;
                     }
 
-                    let Some(key) = property.key.static_name() else { continue };
+                    let Some(key) = property.key.static_name() else {
+                        continue;
+                    };
 
                     let renamed_key = match &property.value.kind {
                         BindingPatternKind::AssignmentPattern(assignment_pattern) => {
@@ -110,7 +111,7 @@ impl Rule for NoUselessRename {
                     };
 
                     if key == renamed_key {
-                        ctx.diagnostic(NoUselessRenameDiagnostic(property.span));
+                        ctx.diagnostic(no_useless_rename_diagnostic(property.span));
                     }
                 }
             }
@@ -127,11 +128,15 @@ impl Rule for NoUselessRename {
                         continue;
                     };
 
-                    let Some(key) = property.name.static_name() else { continue };
-                    let Some(renamed_key) = property.binding.name() else { continue };
+                    let Some(key) = property.name.static_name() else {
+                        continue;
+                    };
+                    let Some(renamed_key) = property.binding.name() else {
+                        continue;
+                    };
 
                     if key == renamed_key {
-                        ctx.diagnostic(NoUselessRenameDiagnostic(property.span));
+                        ctx.diagnostic(no_useless_rename_diagnostic(property.span));
                     }
                 }
             }
@@ -140,7 +145,7 @@ impl Rule for NoUselessRename {
                     && import_specifier.imported.span() != import_specifier.local.span
                     && import_specifier.local.name == import_specifier.imported.name()
                 {
-                    ctx.diagnostic(NoUselessRenameDiagnostic(import_specifier.local.span));
+                    ctx.diagnostic(no_useless_rename_diagnostic(import_specifier.local.span));
                 }
             }
             AstKind::ExportNamedDeclaration(export_named_decl) => {
@@ -151,7 +156,7 @@ impl Rule for NoUselessRename {
                     if specifier.local.span() != specifier.exported.span()
                         && specifier.local.name() == specifier.exported.name()
                     {
-                        ctx.diagnostic(NoUselessRenameDiagnostic(specifier.local.span()));
+                        ctx.diagnostic(no_useless_rename_diagnostic(specifier.local.span()));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/eslint/no_var.rs b/crates/oxc_linter/src/rules/eslint/no_var.rs
index 4ade71dbd529..a2bcad0e5427 100644
--- a/crates/oxc_linter/src/rules/eslint/no_var.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_var.rs
@@ -1,17 +1,16 @@
 use oxc_ast::{ast::VariableDeclarationKind, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-var): Unexpected var, use let or const instead.")]
-#[diagnostic(severity(warning), help("Replace var with let or const"))]
-struct NoVarDiagnostic(#[label] pub Span);
+fn no_var_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-var): Unexpected var, use let or const instead.")
+        .with_help("Replace var with let or const")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoVar;
@@ -46,7 +45,7 @@ impl Rule for NoVar {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::VariableDeclaration(dec) = node.kind() {
             if dec.kind == VariableDeclarationKind::Var {
-                ctx.diagnostic(NoVarDiagnostic(Span::new(dec.span.start, dec.span.start + 3)));
+                ctx.diagnostic(no_var_diagnostic(Span::new(dec.span.start, dec.span.start + 3)));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/eslint/no_void.rs b/crates/oxc_linter/src/rules/eslint/no_void.rs
index e91aba8533af..53b9ef0d9f2a 100644
--- a/crates/oxc_linter/src/rules/eslint/no_void.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_void.rs
@@ -1,18 +1,16 @@
 use crate::{context::LintContext, rule::Rule, AstNode};
+use oxc_diagnostics::OxcDiagnostic;
 
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::UnaryOperator;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-void): Disallow `void` operators")]
-#[diagnostic(severity(warning), help("Expected 'undefined' and instead saw 'void'."))]
-struct NoVoidDiagnostic(#[label] pub Span);
+fn no_void_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-void): Disallow `void` operators")
+        .with_help("Expected 'undefined' and instead saw 'void'.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoVoid {
@@ -63,7 +61,7 @@ impl Rule for NoVoid {
         };
 
         if unary_expr.operator == UnaryOperator::Void {
-            ctx.diagnostic(NoVoidDiagnostic(Span::new(
+            ctx.diagnostic(no_void_diagnostic(Span::new(
                 unary_expr.span.start,
                 unary_expr.span.start + 4,
             )));
diff --git a/crates/oxc_linter/src/rules/eslint/no_with.rs b/crates/oxc_linter/src/rules/eslint/no_with.rs
index 32161ca5072e..26677c371697 100644
--- a/crates/oxc_linter/src/rules/eslint/no_with.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_with.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-with): Unexpected use of `with` statement.")]
-#[diagnostic(severity(warning), help("Do not use the `with` statement."))]
-struct NoWithDiagnostic(#[label] pub Span);
+fn no_with_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-with): Unexpected use of `with` statement.")
+        .with_help("Do not use the `with` statement.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoWith;
@@ -36,7 +35,7 @@ declare_oxc_lint!(
 impl Rule for NoWith {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::WithStatement(with_statement) = node.kind() {
-            ctx.diagnostic(NoWithDiagnostic(Span::new(
+            ctx.diagnostic(no_with_diagnostic(Span::new(
                 with_statement.span.start,
                 with_statement.span.start + 4,
             )));
diff --git a/crates/oxc_linter/src/rules/eslint/radix.rs b/crates/oxc_linter/src/rules/eslint/radix.rs
index ceafe1ccb108..b5fd551bbc81 100644
--- a/crates/oxc_linter/src/rules/eslint/radix.rs
+++ b/crates/oxc_linter/src/rules/eslint/radix.rs
@@ -2,32 +2,29 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum RadixDiagnostic {
-    #[diagnostic(severity(warning))]
-    #[error("eslint(radix): Missing parameters.")]
-    MissingParameters(#[label] Span),
+fn missing_parameters(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(radix): Missing parameters.").with_labels([span0.into()])
+}
 
-    #[diagnostic(severity(warning))]
-    #[error("eslint(radix): Missing radix parameter.")]
-    MissingRadix(#[label] Span),
+fn missing_radix(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(radix): Missing radix parameter.").with_labels([span0.into()])
+}
 
-    #[diagnostic(severity(warning))]
-    #[error("eslint(radix): Redundant radix parameter.")]
-    RedundantRadix(#[label] Span),
+fn redundant_radix(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(radix): Redundant radix parameter.").with_labels([span0.into()])
+}
 
-    #[diagnostic(severity(warning))]
-    #[error("eslint(radix): Invalid radix parameter, must be an integer between 2 and 36.")]
-    InvalidRadix(#[label] Span),
+fn invalid_radix(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint(radix): Invalid radix parameter, must be an integer between 2 and 36.",
+    )
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -109,18 +106,18 @@ impl Rule for Radix {
 impl Radix {
     fn check_arguments(&self, call_expr: &CallExpression, ctx: &LintContext) {
         match call_expr.arguments.len() {
-            0 => ctx.diagnostic(RadixDiagnostic::MissingParameters(call_expr.span)),
+            0 => ctx.diagnostic(missing_parameters(call_expr.span)),
             1 => {
                 if matches!(&self.radix_type, RadixType::Always) {
-                    ctx.diagnostic(RadixDiagnostic::MissingRadix(call_expr.span));
+                    ctx.diagnostic(missing_radix(call_expr.span));
                 }
             }
             _ => {
                 let radix_arg = &call_expr.arguments[1];
                 if matches!(&self.radix_type, RadixType::AsNeeded) && is_default_radix(radix_arg) {
-                    ctx.diagnostic(RadixDiagnostic::RedundantRadix(radix_arg.span()));
+                    ctx.diagnostic(redundant_radix(radix_arg.span()));
                 } else if !is_valid_radix(radix_arg) {
-                    ctx.diagnostic(RadixDiagnostic::InvalidRadix(radix_arg.span()));
+                    ctx.diagnostic(invalid_radix(radix_arg.span()));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/eslint/require_yield.rs b/crates/oxc_linter/src/rules/eslint/require_yield.rs
index 2c5fff6e0545..c7399f251198 100644
--- a/crates/oxc_linter/src/rules/eslint/require_yield.rs
+++ b/crates/oxc_linter/src/rules/eslint/require_yield.rs
@@ -1,17 +1,15 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(require-yield): This generator function does not have 'yield'")]
-#[diagnostic(severity(warning))]
-struct RequireYieldDiagnostic(#[label] pub Span);
+fn require_yield_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(require-yield): This generator function does not have 'yield'")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct RequireYield;
@@ -43,7 +41,7 @@ impl Rule for RequireYield {
                 && func.body.as_ref().is_some_and(|body| !body.statements.is_empty())
             {
                 let span = func.id.as_ref().map_or_else(|| func.span, |ident| ident.span);
-                ctx.diagnostic(RequireYieldDiagnostic(span));
+                ctx.diagnostic(require_yield_diagnostic(span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/eslint/use_isnan.rs b/crates/oxc_linter/src/rules/eslint/use_isnan.rs
index 0d5ef82dc32d..e79bf9d18d4b 100644
--- a/crates/oxc_linter/src/rules/eslint/use_isnan.rs
+++ b/crates/oxc_linter/src/rules/eslint/use_isnan.rs
@@ -1,35 +1,34 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum UseIsnanDiagnostic {
-    #[error("eslint(use-isnan): Requires calls to isNaN() when checking for NaN")]
-    #[diagnostic(severity(warning), help("Use the isNaN function to compare with NaN."))]
-    ComparisonWithNaN(#[label] Span),
-    #[error("eslint(use-isnan): Requires calls to isNaN() when checking for NaN")]
-    #[diagnostic(
-        severity(warning),
-        help(
-            "'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch."
+fn comparison_with_na_n(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(use-isnan): Requires calls to isNaN() when checking for NaN")
+        .with_help("Use the isNaN function to compare with NaN.")
+        .with_labels([span0.into()])
+}
+
+fn switch_na_n(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(use-isnan): Requires calls to isNaN() when checking for NaN")
+        .with_help(
+            "'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch.",
         )
-    )]
-    SwitchNaN(#[label] Span),
-    #[error("eslint(use-isnan): Requires calls to isNaN() when checking for NaN")]
-    #[diagnostic(
-        severity(warning),
-        help("'case NaN' can never match. Use Number.isNaN before the switch.")
-    )]
-    CaseNaN(#[label] Span),
-    #[error("eslint(use-isnan): Requires calls to isNaN() when checking for NaN")]
-    #[diagnostic(severity(warning), help("Array prototype method '{0}' cannot find NaN."))]
-    IndexOfNaN(&'static str, #[label] Span),
+        .with_labels([span0.into()])
+}
+
+fn case_na_n(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(use-isnan): Requires calls to isNaN() when checking for NaN")
+        .with_help("'case NaN' can never match. Use Number.isNaN before the switch.")
+        .with_labels([span0.into()])
+}
+
+fn index_of_na_n(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(use-isnan): Requires calls to isNaN() when checking for NaN")
+        .with_help(format!("Array prototype method '{x0}' cannot find NaN."))
+        .with_labels([span1.into()])
 }
 
 #[derive(Debug, Clone)]
@@ -81,22 +80,22 @@ impl Rule for UseIsnan {
                 if expr.operator.is_compare() || expr.operator.is_equality() =>
             {
                 if is_nan_identifier(&expr.left) {
-                    ctx.diagnostic(UseIsnanDiagnostic::ComparisonWithNaN(expr.left.span()));
+                    ctx.diagnostic(comparison_with_na_n(expr.left.span()));
                 }
                 if is_nan_identifier(&expr.right) {
-                    ctx.diagnostic(UseIsnanDiagnostic::ComparisonWithNaN(expr.right.span()));
+                    ctx.diagnostic(comparison_with_na_n(expr.right.span()));
                 }
             }
             AstKind::SwitchCase(case) if self.enforce_for_switch_case => {
                 if let Some(test) = &case.test {
                     if is_nan_identifier(test) {
-                        ctx.diagnostic(UseIsnanDiagnostic::CaseNaN(test.span()));
+                        ctx.diagnostic(case_na_n(test.span()));
                     }
                 }
             }
             AstKind::SwitchStatement(switch) if self.enforce_for_switch_case => {
                 if is_nan_identifier(&switch.discriminant) {
-                    ctx.diagnostic(UseIsnanDiagnostic::SwitchNaN(switch.discriminant.span()));
+                    ctx.diagnostic(switch_na_n(switch.discriminant.span()));
                 }
             }
             AstKind::CallExpression(call) if self.enforce_for_index_of => {
@@ -105,7 +104,7 @@ impl Rule for UseIsnan {
                     if call.arguments.len() == 1 {
                         if let Some(expr) = call.arguments[0].as_expression() {
                             if is_nan_identifier(expr) {
-                                ctx.diagnostic(UseIsnanDiagnostic::IndexOfNaN(method, expr.span()));
+                                ctx.diagnostic(index_of_na_n(method, expr.span()));
                             }
                         }
                     }
@@ -383,88 +382,31 @@ fn test() {
         ("switch(NaN) { case foo: break; }", Some(serde_json::json!([{}]))),
         ("switch(foo) { case NaN: break; }", Some(serde_json::json!([{}]))),
         ("switch(NaN) {}", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
-        (
-            "switch(NaN) { case foo: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(NaN) { default: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(NaN) { case foo: break; default: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
+        ("switch(NaN) { case foo: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(NaN) { default: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(NaN) { case foo: break; default: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
         ("switch(foo) { case NaN: }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
-        (
-            "switch(foo) { case NaN: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(foo) { case (NaN): break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(foo) { case bar: break; case NaN: break; default: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(foo) { case bar: case NaN: default: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(foo) { case bar: break; case NaN: break; case baz: break; case NaN: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(NaN) { case NaN: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
+        ("switch(foo) { case NaN: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(foo) { case (NaN): break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(foo) { case bar: break; case NaN: break; default: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(foo) { case bar: case NaN: default: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(foo) { case bar: break; case NaN: break; case baz: break; case NaN: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(NaN) { case NaN: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
         ("switch(Number.NaN) { case foo: break; }", None),
         ("switch(foo) { case Number.NaN: break; }", None),
         ("switch(Number.NaN) { case foo: break; }", Some(serde_json::json!([{}]))),
         ("switch(foo) { case Number.NaN: break; }", Some(serde_json::json!([{}]))),
         ("switch(Number.NaN) {}", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
-        (
-            "switch(Number.NaN) { case foo: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(Number.NaN) { default: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(Number.NaN) { case foo: break; default: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(foo) { case Number.NaN: }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(foo) { case Number.NaN: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(foo) { case (Number.NaN): break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(foo) { case bar: break; case Number.NaN: break; default: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(foo) { case bar: case Number.NaN: default: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(foo) { case bar: break; case NaN: break; case baz: break; case Number.NaN: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
-        (
-            "switch(Number.NaN) { case Number.NaN: break; }",
-            Some(serde_json::json!([{ "enforceForSwitchCase": true }])),
-        ),
+        ("switch(Number.NaN) { case foo: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(Number.NaN) { default: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(Number.NaN) { case foo: break; default: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(foo) { case Number.NaN: }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(foo) { case Number.NaN: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(foo) { case (Number.NaN): break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(foo) { case bar: break; case Number.NaN: break; default: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(foo) { case bar: case Number.NaN: default: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(foo) { case bar: break; case NaN: break; case baz: break; case Number.NaN: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
+        ("switch(Number.NaN) { case Number.NaN: break; }", Some(serde_json::json!([{ "enforceForSwitchCase": true }]))),
         ("foo.indexOf(NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
         ("foo.lastIndexOf(NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
         ("foo['indexOf'](NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
@@ -477,15 +419,9 @@ fn test() {
         ("foo.indexOf(Number.NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
         ("foo.lastIndexOf(Number.NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
         ("foo['indexOf'](Number.NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
-        (
-            "foo['lastIndexOf'](Number.NaN)",
-            Some(serde_json::json!([{ "enforceForIndexOf": true }])),
-        ),
+        ("foo['lastIndexOf'](Number.NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
         ("foo().indexOf(Number.NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
-        (
-            "foo.bar.lastIndexOf(Number.NaN)",
-            Some(serde_json::json!([{ "enforceForIndexOf": true }])),
-        ),
+        ("foo.bar.lastIndexOf(Number.NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
         ("foo.indexOf?.(Number.NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
         ("foo?.indexOf(Number.NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
         ("(foo?.indexOf)(Number.NaN)", Some(serde_json::json!([{ "enforceForIndexOf": true }]))),
diff --git a/crates/oxc_linter/src/rules/eslint/valid_typeof.rs b/crates/oxc_linter/src/rules/eslint/valid_typeof.rs
index 2a5da67d9e82..287398ca2b81 100644
--- a/crates/oxc_linter/src/rules/eslint/valid_typeof.rs
+++ b/crates/oxc_linter/src/rules/eslint/valid_typeof.rs
@@ -1,8 +1,5 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::UnaryOperator;
@@ -10,14 +7,24 @@ use phf::{phf_set, Set};
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum ValidTypeofDiagnostic {
-    #[error("eslint(valid-typeof): Typeof comparisons should be to string literals.")]
-    #[diagnostic(severity(warning))]
-    NotString(#[help] Option<&'static str>, #[label] Span),
-    #[error("eslint(valid-typeof): Invalid typeof comparison value.")]
-    #[diagnostic(severity(warning))]
-    InvalidValue(#[help] Option<&'static str>, #[label] Span),
+fn not_string(x0: Option<&'static str>, span1: Span) -> OxcDiagnostic {
+    let mut d = OxcDiagnostic::warning(
+        "eslint(valid-typeof): Typeof comparisons should be to string literals.",
+    )
+    .with_labels([span1.into()]);
+    if let Some(x) = x0 {
+        d = d.with_help(x);
+    }
+    d
+}
+
+fn invalid_value(x0: Option<&'static str>, span1: Span) -> OxcDiagnostic {
+    let mut d = OxcDiagnostic::warning("eslint(valid-typeof): Invalid typeof comparison value.")
+        .with_labels([span1.into()]);
+    if let Some(x) = x0 {
+        d = d.with_help(x);
+    }
+    d
 }
 
 #[derive(Debug, Clone, Default)]
@@ -75,7 +82,7 @@ impl Rule for ValidTypeof {
 
         if let Expression::StringLiteral(lit) = sibling {
             if !VALID_TYPES.contains(lit.value.as_str()) {
-                ctx.diagnostic(ValidTypeofDiagnostic::InvalidValue(None, sibling.span()));
+                ctx.diagnostic(invalid_value(None, sibling.span()));
             }
             return;
         }
@@ -83,7 +90,7 @@ impl Rule for ValidTypeof {
         if let Expression::TemplateLiteral(template) = sibling {
             if template.expressions.is_empty() {
                 if template.quasi().is_some_and(|value| !VALID_TYPES.contains(value.as_str())) {
-                    ctx.diagnostic(ValidTypeofDiagnostic::InvalidValue(None, sibling.span()));
+                    ctx.diagnostic(invalid_value(None, sibling.span()));
                 }
                 return;
             }
@@ -93,12 +100,12 @@ impl Rule for ValidTypeof {
             if ident.name == "undefined" && ctx.semantic().is_reference_to_global_variable(ident) {
                 ctx.diagnostic_with_fix(
                     if self.require_string_literals {
-                        ValidTypeofDiagnostic::NotString(
+                        not_string(
                             Some("Use `\"undefined\"` instead of `undefined`."),
                             sibling.span(),
                         )
                     } else {
-                        ValidTypeofDiagnostic::InvalidValue(
+                        invalid_value(
                             Some("Use `\"undefined\"` instead of `undefined`."),
                             sibling.span(),
                         )
@@ -112,7 +119,7 @@ impl Rule for ValidTypeof {
         if self.require_string_literals
             && !matches!(sibling, Expression::UnaryExpression(unary) if unary.operator == UnaryOperator::Typeof)
         {
-            ctx.diagnostic(ValidTypeofDiagnostic::NotString(None, sibling.span()));
+            ctx.diagnostic(not_string(None, sibling.span()));
         }
     }
 
diff --git a/crates/oxc_linter/src/rules/import/default.rs b/crates/oxc_linter/src/rules/import/default.rs
index 6ad4830f5443..9f2f45827f9b 100644
--- a/crates/oxc_linter/src/rules/import/default.rs
+++ b/crates/oxc_linter/src/rules/import/default.rs
@@ -1,17 +1,18 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::module_record::ImportImportName;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-import(default): No default export found in imported module {0:?}")]
-#[diagnostic(severity(warning), help("does {0:?} have the default export?"))]
-struct DefaultDiagnostic(String, #[label] pub Span);
+fn default_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-import(default): No default export found in imported module {x0:?}"
+    ))
+    .with_help(format!("does {x0:?} have the default export?"))
+    .with_labels([span1.into()])
+}
 
 /// <https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/default.md>
 #[derive(Debug, Default, Clone)]
@@ -53,7 +54,7 @@ impl Rule for Default {
             if remote_module_record_ref.export_default.is_none()
                 && !remote_module_record_ref.exported_bindings.contains_key("default")
             {
-                ctx.diagnostic(DefaultDiagnostic(specifier.to_string(), default_span));
+                ctx.diagnostic(default_diagnostic(specifier, default_span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/import/export.rs b/crates/oxc_linter/src/rules/import/export.rs
index da72b4408224..904ae80ac002 100644
--- a/crates/oxc_linter/src/rules/import/export.rs
+++ b/crates/oxc_linter/src/rules/import/export.rs
@@ -1,10 +1,6 @@
 use std::path::PathBuf;
 
-use oxc_diagnostics::{
-    miette::{self, miette, Diagnostic, LabeledSpan},
-    thiserror::{self, Error},
-    Severity,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::ModuleRecord;
 use oxc_span::{CompactStr, Span};
@@ -12,11 +8,11 @@ use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-enum ExportDiagnostic {
-    #[error("eslint-plugin-import(export): No named exports found in module '{1}'")]
-    #[diagnostic(severity(warning))]
-    NoNamedExport(#[label] Span, CompactStr),
+fn no_named_export(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-import(export): No named exports found in module '{x1}'"
+    ))
+    .with_labels([span0.into()])
 }
 
 /// <https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/export.md>
@@ -48,7 +44,9 @@ impl Rule for Export {
         module_record.star_export_entries.iter().for_each(|star_export_entry| {
             let mut export_names = FxHashSet::default();
 
-            let Some(module_request) = &star_export_entry.module_request else { return };
+            let Some(module_request) = &star_export_entry.module_request else {
+                return;
+            };
             let Some(remote_module_record_ref) =
                 module_record.loaded_modules.get(module_request.name())
             else {
@@ -62,10 +60,7 @@ impl Rule for Export {
             );
 
             if export_names.is_empty() {
-                ctx.diagnostic(ExportDiagnostic::NoNamedExport(
-                    module_request.span(),
-                    module_request.name().clone(),
-                ));
+                ctx.diagnostic(no_named_export(module_request.span(), module_request.name()));
             } else {
                 all_export_names.insert(star_export_entry.span, export_names);
             }
@@ -93,11 +88,12 @@ impl Rule for Export {
                 spans.push(*span);
                 let labels = spans.into_iter().map(LabeledSpan::underline).collect::<Vec<_>>();
 
-                ctx.diagnostic(miette!(
-                    severity = Severity::Warning,
-                    labels = labels,
-                    "eslint-plugin-import(export): Multiple exports of name '{name}'."
-                ));
+                ctx.diagnostic(
+                    OxcDiagnostic::warning(format!(
+                        "eslint-plugin-import(export): Multiple exports of name '{name}'."
+                    ))
+                    .with_labels(labels),
+                );
             }
         }
 
@@ -106,12 +102,12 @@ impl Rule for Export {
             if let Some(span) = module_record.export_default {
                 spans.push(span);
                 let labels = spans.into_iter().map(LabeledSpan::underline).collect::<Vec<_>>();
-
-                ctx.diagnostic(miette!(
-                    severity = Severity::Warning,
-                    labels = labels,
-                    "eslint-plugin-import(export): Multiple default exports."
-                ));
+                ctx.diagnostic(
+                    OxcDiagnostic::warning(
+                        "eslint-plugin-import(export): Multiple default exports.",
+                    )
+                    .with_labels(labels),
+                );
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/import/named.rs b/crates/oxc_linter/src/rules/import/named.rs
index 5784daa1b438..ade4c5d3574d 100644
--- a/crates/oxc_linter/src/rules/import/named.rs
+++ b/crates/oxc_linter/src/rules/import/named.rs
@@ -1,17 +1,16 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::module_record::{ExportImportName, ImportImportName};
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-import(named): named import {0:?} not found")]
-#[diagnostic(severity(warning), help("does {1:?} have the export {0:?}?"))]
-struct NamedDiagnostic(String, String, #[label] pub Span);
+fn named_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-import(named): named import {x0:?} not found"))
+        .with_help(format!("does {x1:?} have the export {x0:?}?"))
+        .with_labels([span2.into()])
+}
 
 /// <https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/named.md>
 #[derive(Debug, Default, Clone)]
@@ -67,11 +66,7 @@ impl Rule for Named {
                 continue;
             }
 
-            ctx.diagnostic(NamedDiagnostic(
-                import_name.name().to_string(),
-                specifier.to_string(),
-                import_name.span(),
-            ));
+            ctx.diagnostic(named_diagnostic(import_name.name(), specifier, import_name.span()));
         }
 
         for export_entry in &module_record.indirect_export_entries {
@@ -96,11 +91,7 @@ impl Rule for Named {
             if remote_module_record.exported_bindings.contains_key(name) {
                 continue;
             }
-            ctx.diagnostic(NamedDiagnostic(
-                name.to_string(),
-                specifier.to_string(),
-                import_name.span(),
-            ));
+            ctx.diagnostic(named_diagnostic(name, specifier, import_name.span()));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/import/namespace.rs b/crates/oxc_linter/src/rules/import/namespace.rs
index 2d4b8bda530a..8941548f62c9 100644
--- a/crates/oxc_linter/src/rules/import/namespace.rs
+++ b/crates/oxc_linter/src/rules/import/namespace.rs
@@ -4,10 +4,7 @@ use oxc_ast::{
     ast::{BindingPatternKind, ObjectPattern},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{AstNode, ModuleRecord};
 use oxc_span::{CompactStr, GetSpan, Span};
@@ -15,23 +12,29 @@ use oxc_syntax::module_record::{ExportExportName, ExportImportName, ImportImport
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NamespaceDiagnostic {
-    #[error("eslint-plugin-import(namespace): {1:?} not found in imported namespace {2:?}.")]
-    #[diagnostic(severity(warning))]
-    NoExport(#[label] Span, CompactStr, String),
-    #[error(
-        "eslint-plugin-import(namespace): {1:?} not found in deeply imported namespace {2:?}."
-    )]
-    #[diagnostic(severity(warning))]
-    NoExportInDeeplyImportedNamespace(#[label] Span, CompactStr, String),
-    #[error("eslint-plugin-import(namespace): Unable to validate computed reference to imported namespace {1:?}
-    .")]
-    #[diagnostic(severity(warning))]
-    ComputedReference(#[label] Span, CompactStr),
-    #[error("eslint-plugin-import(namespace): Assignment to member of namespace {1:?}.'")]
-    #[diagnostic(severity(warning))]
-    Assignment(#[label] Span, CompactStr),
+fn no_export(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-import(namespace): {x1:?} not found in imported namespace {x2:?}."
+    ))
+    .with_labels([span0.into()])
+}
+
+fn no_export_in_deeply_imported_namespace(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-import(namespace): {x1:?} not found in deeply imported namespace {x2:?}."
+    ))
+    .with_labels([span0.into()])
+}
+
+fn computed_reference(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-import(namespace): Unable to validate computed reference to imported namespace {x1:?}.")).with_labels([span0.into()])
+}
+
+fn assignment(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-import(namespace): Assignment to member of namespace {x1:?}.'"
+    ))
+    .with_labels([span0.into()])
 }
 
 /// <https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/namespace.md>
@@ -116,17 +119,11 @@ impl Rule for Namespace {
                                 ctx.nodes().parent_kind(node.id()),
                                 Some(AstKind::SimpleAssignmentTarget(_))
                             ) {
-                                ctx.diagnostic(NamespaceDiagnostic::Assignment(
-                                    member.span(),
-                                    name.clone(),
-                                ));
+                                ctx.diagnostic(assignment(member.span(), name));
                             };
 
                             if !self.allow_computed && member.is_computed() {
-                                return ctx.diagnostic(NamespaceDiagnostic::ComputedReference(
-                                    member.span(),
-                                    name.clone(),
-                                ));
+                                return ctx.diagnostic(computed_reference(member.span(), name));
                             }
 
                             check_deep_namespace_for_node(
@@ -143,13 +140,7 @@ impl Rule for Namespace {
                             {
                                 check_binding_exported(
                                     &expr.property.name,
-                                    || {
-                                        NamespaceDiagnostic::NoExport(
-                                            expr.property.span,
-                                            expr.property.name.to_compact_str(),
-                                            source.clone(),
-                                        )
-                                    },
+                                    || no_export(expr.property.span, &expr.property.name, &source),
                                     &module,
                                     ctx,
                                 );
@@ -199,7 +190,7 @@ fn get_module_request_name(name: &str, module_record: &ModuleRecord) -> Option<S
                 false
             }
             ExportImportName::Name(name_span) => {
-                return name_span.name().as_str() == name
+                name_span.name().as_str() == name
                     && module_record.import_entries.iter().any(|entry| {
                         entry.local_name.name().as_str() == name
                             && entry.import_name.is_namespace_object()
@@ -211,13 +202,13 @@ fn get_module_request_name(name: &str, module_record: &ModuleRecord) -> Option<S
         return entry.module_request.as_ref().map(|name| name.name().to_string());
     };
 
-    return module_record
+    module_record
         .import_entries
         .iter()
         .find(|entry| {
             entry.local_name.name().as_str() == name && entry.import_name.is_namespace_object()
         })
-        .map(|entry| entry.module_request.name().to_string());
+        .map(|entry| entry.module_request.name().to_string())
 }
 
 fn check_deep_namespace_for_node(
@@ -251,13 +242,9 @@ fn check_deep_namespace_for_node(
                 name,
                 || {
                     if namespaces.len() > 1 {
-                        NamespaceDiagnostic::NoExportInDeeplyImportedNamespace(
-                            span,
-                            name.into(),
-                            namespaces.join("."),
-                        )
+                        no_export_in_deeply_imported_namespace(span, name, &namespaces.join("."))
                     } else {
-                        NamespaceDiagnostic::NoExport(span, name.into(), source.to_string())
+                        no_export(span, name, source)
                     }
                 },
                 module,
@@ -298,17 +285,13 @@ fn check_deep_namespace_for_object_pattern(
             &name,
             || {
                 if namespaces.len() > 1 {
-                    NamespaceDiagnostic::NoExportInDeeplyImportedNamespace(
+                    no_export_in_deeply_imported_namespace(
                         property.key.span(),
-                        name.clone(),
-                        namespaces.join("."),
+                        &name,
+                        &namespaces.join("."),
                     )
                 } else {
-                    NamespaceDiagnostic::NoExport(
-                        property.key.span(),
-                        name.clone(),
-                        source.to_string(),
-                    )
+                    no_export(property.key.span(), &name, source)
                 }
             },
             module,
@@ -319,7 +302,7 @@ fn check_deep_namespace_for_object_pattern(
 
 fn check_binding_exported(
     name: &str,
-    get_diagnostic: impl FnOnce() -> NamespaceDiagnostic,
+    get_diagnostic: impl FnOnce() -> OxcDiagnostic,
     module: &ModuleRecord,
     ctx: &LintContext<'_>,
 ) {
diff --git a/crates/oxc_linter/src/rules/import/no_amd.rs b/crates/oxc_linter/src/rules/import/no_amd.rs
index 482598aab070..0c283d325b90 100644
--- a/crates/oxc_linter/src/rules/import/no_amd.rs
+++ b/crates/oxc_linter/src/rules/import/no_amd.rs
@@ -1,18 +1,19 @@
 use oxc_ast::ast::{Argument, Expression};
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-import(no-amd): Do not use AMD `require` and `define` calls.")]
-#[diagnostic(severity(warning), help("Expected imports instead of AMD {1}()"))]
-struct NoAmdDiagnostic(#[label] pub Span, CompactStr);
+fn no_amd_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-import(no-amd): Do not use AMD `require` and `define` calls.",
+    )
+    .with_help(format!("Expected imports instead of AMD {x1}()"))
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAmd;
@@ -53,10 +54,7 @@ impl Rule for NoAmd {
                 }
 
                 if let Argument::ArrayExpression(_) = call_expr.arguments[0] {
-                    ctx.diagnostic(NoAmdDiagnostic(
-                        identifier.span,
-                        identifier.name.to_compact_str(),
-                    ));
+                    ctx.diagnostic(no_amd_diagnostic(identifier.span, identifier.name.as_str()));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/import/no_cycle.rs b/crates/oxc_linter/src/rules/import/no_cycle.rs
index 183a3be7a620..de620ba3cbe0 100644
--- a/crates/oxc_linter/src/rules/import/no_cycle.rs
+++ b/crates/oxc_linter/src/rules/import/no_cycle.rs
@@ -1,11 +1,8 @@
 #![allow(clippy::cast_possible_truncation)]
+use oxc_diagnostics::OxcDiagnostic;
 
 use std::{ffi::OsStr, path::Component, sync::Arc};
 
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{CompactStr, Span};
 use oxc_syntax::{
@@ -15,10 +12,11 @@ use oxc_syntax::{
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-import(no-cycle): Dependency cycle detected")]
-#[diagnostic(severity(warning), help("These paths form a cycle: \n{1}"))]
-struct NoCycleDiagnostic(#[label] Span, String);
+fn no_cycle_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-import(no-cycle): Dependency cycle detected")
+        .with_help(format!("These paths form a cycle: \n{x1}"))
+        .with_labels([span0.into()])
+}
 
 /// <https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-cycle.md>
 #[derive(Debug, Clone)]
@@ -154,7 +152,7 @@ impl Rule for NoCycle {
                 })
                 .collect::<Vec<_>>()
                 .join("\n");
-            ctx.diagnostic(NoCycleDiagnostic(span, help));
+            ctx.diagnostic(no_cycle_diagnostic(span, &help));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/import/no_default_export.rs b/crates/oxc_linter/src/rules/import/no_default_export.rs
index 8d8daba9239d..b5c4e9bb79f8 100644
--- a/crates/oxc_linter/src/rules/import/no_default_export.rs
+++ b/crates/oxc_linter/src/rules/import/no_default_export.rs
@@ -1,16 +1,14 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-import(no-default-export): Prefer named exports")]
-#[diagnostic(severity(warning))]
-struct NoDefaultExportDiagnostic(#[label] Span);
+fn no_default_export_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-import(no-default-export): Prefer named exports")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDefaultExport;
@@ -53,7 +51,7 @@ impl Rule for NoDefaultExport {
 }
 
 fn write_diagnostic(ctx: &LintContext<'_>, span: Span) {
-    ctx.diagnostic(NoDefaultExportDiagnostic(span));
+    ctx.diagnostic(no_default_export_diagnostic(span));
 }
 fn write_diagnostic_optional(ctx: &LintContext<'_>, span_option: Option<Span>) {
     if let Some(span) = span_option {
diff --git a/crates/oxc_linter/src/rules/import/no_deprecated.rs b/crates/oxc_linter/src/rules/import/no_deprecated.rs
index 334dcb10f71d..61c511eda019 100644
--- a/crates/oxc_linter/src/rules/import/no_deprecated.rs
+++ b/crates/oxc_linter/src/rules/import/no_deprecated.rs
@@ -1,7 +1,4 @@
-// use oxc_diagnostics::{
-//     miette::{self, Diagnostic},
-//     thiserror::Error,
-// };
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
 use oxc_macros::declare_oxc_lint;
 // use oxc_span::{CompactStr, Span};
 
diff --git a/crates/oxc_linter/src/rules/import/no_duplicates.rs b/crates/oxc_linter/src/rules/import/no_duplicates.rs
index 2fc727e879d8..1cb81ed8cb39 100644
--- a/crates/oxc_linter/src/rules/import/no_duplicates.rs
+++ b/crates/oxc_linter/src/rules/import/no_duplicates.rs
@@ -1,5 +1,5 @@
 use itertools::Itertools;
-use oxc_diagnostics::miette::{miette, LabeledSpan, Severity};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
 use oxc_macros::declare_oxc_lint;
 use oxc_syntax::module_record::{ImportImportName, RequestedModule};
 
@@ -51,11 +51,7 @@ impl Rule for NoDuplicates {
                         .iter()
                         .map(|requested_module| LabeledSpan::underline(requested_module.span()))
                         .collect::<Vec<_>>();
-                    ctx.diagnostic(miette!(
-                            severity = Severity::Warning,
-                            labels = labels,
-                            "eslint-plugin-import(no-duplicates): Forbid repeated import of the same module in multiple places"
-                        ));
+                    ctx.diagnostic(OxcDiagnostic::warning("eslint-plugin-import(no-duplicates): Forbid repeated import of the same module in multiple places").with_labels(labels));
                 }
             }
         };
diff --git a/crates/oxc_linter/src/rules/import/no_named_as_default.rs b/crates/oxc_linter/src/rules/import/no_named_as_default.rs
index d453318514a9..53a73da93a3b 100644
--- a/crates/oxc_linter/src/rules/import/no_named_as_default.rs
+++ b/crates/oxc_linter/src/rules/import/no_named_as_default.rs
@@ -1,17 +1,16 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::module_record::ImportImportName;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-import(no-named-as-default): Module {2:?} has named export {1:?}")]
-#[diagnostic(severity(warning), help("Using default import as {1:?} can be confusing. Use another name for default import to avoid confusion."))]
-struct NoNamedAsDefaultDiagnostic(#[label] pub Span, String, String);
+fn no_named_as_default_diagnostic(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-import(no-named-as-default): Module {x2:?} has named export {x1:?}"))
+        .with_help(format!("Using default import as {x1:?} can be confusing. Use another name for default import to avoid confusion."))
+        .with_labels([span0.into()])
+}
 
 /// <https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-named-as-default-member.md>
 #[derive(Debug, Default, Clone)]
@@ -57,10 +56,10 @@ impl Rule for NoNamedAsDefault {
 
             let import_name = import_entry.local_name.name();
             if remote_module_record_ref.exported_bindings.contains_key(import_name) {
-                ctx.diagnostic(NoNamedAsDefaultDiagnostic(
+                ctx.diagnostic(no_named_as_default_diagnostic(
                     *import_span,
-                    import_name.to_string(),
-                    import_entry.module_request.name().to_string(),
+                    import_name,
+                    import_entry.module_request.name(),
                 ));
             }
         }
diff --git a/crates/oxc_linter/src/rules/import/no_named_as_default_member.rs b/crates/oxc_linter/src/rules/import/no_named_as_default_member.rs
index 45edaf96dad9..1db024b49906 100644
--- a/crates/oxc_linter/src/rules/import/no_named_as_default_member.rs
+++ b/crates/oxc_linter/src/rules/import/no_named_as_default_member.rs
@@ -1,4 +1,6 @@
-#![allow(clippy::significant_drop_tightening)]
+use oxc_diagnostics::OxcDiagnostic;
+// #![allow(clippy::significant_drop_tightening)]
+
 use std::collections::HashMap;
 
 use dashmap::mapref::one::Ref;
@@ -6,10 +8,6 @@ use oxc_ast::{
     ast::{BindingPatternKind, Expression, IdentifierReference, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::SymbolId;
 use oxc_span::{CompactStr, Span};
@@ -17,10 +15,18 @@ use oxc_syntax::module_record::ImportImportName;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-import(no-named-as-default-member): {1:?} also has a named export {2:?}")]
-#[diagnostic(severity(warning), help("Check if you meant to write `import {{{2:}}} from {3:?}`"))]
-struct NoNamedAsDefaultMemberDignostic(#[label] pub Span, String, String, String);
+fn no_named_as_default_member_dignostic(
+    span0: Span,
+    x1: &str,
+    x2: &str,
+    x3: &str,
+) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-import(no-named-as-default-member): {x1:?} also has a named export {x2:?}"
+    ))
+    .with_help(format!("Check if you meant to write `import {{{x2:}}} from {x3:?}`"))
+    .with_labels([span0.into()])
+}
 
 /// <https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-named-as-default-member.md>
 #[derive(Debug, Default, Clone)]
@@ -102,15 +108,15 @@ impl Rule for NoNamedAsDefaultMember {
                 return;
             };
             if let Some(module_name) = get_external_module_name_if_has_entry(ident, prop_str) {
-                ctx.diagnostic(NoNamedAsDefaultMemberDignostic(
+                ctx.diagnostic(no_named_as_default_member_dignostic(
                     match member_expr {
                         MemberExpression::ComputedMemberExpression(it) => it.span,
                         MemberExpression::StaticMemberExpression(it) => it.span,
                         MemberExpression::PrivateFieldExpression(it) => it.span,
                     },
-                    ident.name.to_string(),
-                    prop_str.to_string(),
-                    module_name,
+                    &ident.name,
+                    prop_str,
+                    &module_name,
                 ));
             };
         };
@@ -133,11 +139,11 @@ impl Rule for NoNamedAsDefaultMember {
                         if let Some(module_name) =
                             get_external_module_name_if_has_entry(ident, &name)
                         {
-                            ctx.diagnostic(NoNamedAsDefaultMemberDignostic(
+                            ctx.diagnostic(no_named_as_default_member_dignostic(
                                 decl.span,
-                                ident.name.to_string(),
-                                name.to_string(),
-                                module_name,
+                                &ident.name,
+                                &name,
+                                &module_name,
                             ));
                         }
                     }
diff --git a/crates/oxc_linter/src/rules/import/no_self_import.rs b/crates/oxc_linter/src/rules/import/no_self_import.rs
index c877d3ea0ec7..5c8e5ba0f568 100644
--- a/crates/oxc_linter/src/rules/import/no_self_import.rs
+++ b/crates/oxc_linter/src/rules/import/no_self_import.rs
@@ -1,16 +1,16 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-import(no-self-import): module importing itself is not allowed")]
-#[diagnostic(severity(warning))]
-struct NoSelfImportDiagnostic(#[label] pub Span);
+fn no_self_import_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-import(no-self-import): module importing itself is not allowed",
+    )
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoSelfImport;
@@ -41,7 +41,7 @@ impl Rule for NoSelfImport {
             };
             if remote_module_record_ref.value().resolved_absolute_path == *resolved_absolute_path {
                 for requested_module in requested_modules {
-                    ctx.diagnostic(NoSelfImportDiagnostic(requested_module.span()));
+                    ctx.diagnostic(no_self_import_diagnostic(requested_module.span()));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/import/no_unused_modules.rs b/crates/oxc_linter/src/rules/import/no_unused_modules.rs
index 85aca2301d3b..e38d87470baf 100644
--- a/crates/oxc_linter/src/rules/import/no_unused_modules.rs
+++ b/crates/oxc_linter/src/rules/import/no_unused_modules.rs
@@ -1,17 +1,11 @@
-use oxc_diagnostics::{
-    miette::{self, diagnostic, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoUnusedModulesDiagnostic {
-    #[error("eslint-plugin-import(no-unused-modules): No exports found")]
-    #[diagnostic(severity(warning))]
-    NoExportsFound(#[label] Span),
+fn no_exports_found(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-import(no-unused-modules): No exports found")
+        .with_labels([span0.into()])
 }
 
 /// <https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/no-unused-modules.md>
@@ -50,7 +44,7 @@ impl Rule for NoUnusedModules {
     fn run_once(&self, ctx: &LintContext<'_>) {
         let module_record = ctx.semantic().module_record();
         if self.missing_exports && module_record.local_export_entries.is_empty() {
-            ctx.diagnostic(NoUnusedModulesDiagnostic::NoExportsFound(Span::new(0, 0)));
+            ctx.diagnostic(no_exports_found(Span::new(0, 0)));
         }
         if self.unused_exports {
             // TODO: implement unused exports
diff --git a/crates/oxc_linter/src/rules/jest/expect_expect.rs b/crates/oxc_linter/src/rules/jest/expect_expect.rs
index eda55d8f35b5..27a33daa1aab 100644
--- a/crates/oxc_linter/src/rules/jest/expect_expect.rs
+++ b/crates/oxc_linter/src/rules/jest/expect_expect.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{CallExpression, Expression, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use regex::Regex;
@@ -20,10 +18,11 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(expect-expect): Test has no assertions")]
-#[diagnostic(severity(warning), help("Add assertion(s) in this Test"))]
-struct ExpectExpectDiagnostic(#[label] pub Span);
+fn expect_expect_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(expect-expect): Test has no assertions")
+        .with_help("Add assertion(s) in this Test")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ExpectExpect(Box<ExpectExpectConfig>);
@@ -131,7 +130,7 @@ fn run<'a>(
             let has_assert_function = check_arguments(call_expr, &rule.assert_function_names, ctx);
 
             if !has_assert_function {
-                ctx.diagnostic(ExpectExpectDiagnostic(call_expr.callee.span()));
+                ctx.diagnostic(expect_expect_diagnostic(call_expr.callee.span()));
             }
         }
     }
@@ -251,18 +250,9 @@ fn test() {
             ",
             Some(serde_json::json!([{ "assertFunctionNames": ["expect", "foo"] }])),
         ),
-        (
-            "it('should return undefined',() => expectSaga(mySaga).returns());",
-            Some(serde_json::json!([{ "assertFunctionNames": ["expectSaga"] }])),
-        ),
-        (
-            "test('verifies expect method call', () => expect$(123));",
-            Some(serde_json::json!([{ "assertFunctionNames": ["expect\\$"] }])),
-        ),
-        (
-            "test('verifies expect method call', () => new Foo().expect(123));",
-            Some(serde_json::json!([{ "assertFunctionNames": ["Foo.expect"] }])),
-        ),
+        ("it('should return undefined',() => expectSaga(mySaga).returns());", Some(serde_json::json!([{ "assertFunctionNames": ["expectSaga"] }]))),
+        ("test('verifies expect method call', () => expect$(123));", Some(serde_json::json!([{ "assertFunctionNames": ["expect\\$"] }]))),
+        ("test('verifies expect method call', () => new Foo().expect(123));", Some(serde_json::json!([{ "assertFunctionNames": ["Foo.expect"] }]))),
         (
             "
         	test('verifies deep expect method call', () => {
@@ -308,46 +298,16 @@ fn test() {
             ",
             Some(serde_json::json!([{ "additionalTestBlockFunctions": ["theoretically"] }])),
         ),
-        (
-            "test('should pass *', () => expect404ToBeLoaded());",
-            Some(serde_json::json!([{ "assertFunctionNames": ["expect*"] }])),
-        ),
-        (
-            "test('should pass *', () => expect.toHaveStatus404());",
-            Some(serde_json::json!([{ "assertFunctionNames": ["expect.**"] }])),
-        ),
-        (
-            "test('should pass', () => tester.foo().expect(123));",
-            Some(serde_json::json!([{ "assertFunctionNames": ["tester.*.expect"] }])),
-        ),
-        (
-            "test('should pass **', () => tester.foo().expect(123));",
-            Some(serde_json::json!([{ "assertFunctionNames": ["**"] }])),
-        ),
-        (
-            "test('should pass *', () => tester.foo().expect(123));",
-            Some(serde_json::json!([{ "assertFunctionNames": ["*"] }])),
-        ),
-        (
-            "test('should pass', () => tester.foo().expect(123));",
-            Some(serde_json::json!([{ "assertFunctionNames": ["tester.**"] }])),
-        ),
-        (
-            "test('should pass', () => tester.foo().expect(123));",
-            Some(serde_json::json!([{ "assertFunctionNames": ["tester.*"] }])),
-        ),
-        (
-            "test('should pass', () => tester.foo().bar().expectIt(456));",
-            Some(serde_json::json!([{ "assertFunctionNames": ["tester.**.expect*"] }])),
-        ),
-        (
-            "test('should pass', () => request.get().foo().expect(456));",
-            Some(serde_json::json!([{ "assertFunctionNames": ["request.**.expect"] }])),
-        ),
-        (
-            "test('should pass', () => request.get().foo().expect(456));",
-            Some(serde_json::json!([{ "assertFunctionNames": ["request.**.e*e*t"] }])),
-        ),
+        ("test('should pass *', () => expect404ToBeLoaded());", Some(serde_json::json!([{ "assertFunctionNames": ["expect*"] }]))),
+        ("test('should pass *', () => expect.toHaveStatus404());", Some(serde_json::json!([{ "assertFunctionNames": ["expect.**"] }]))),
+        ("test('should pass', () => tester.foo().expect(123));", Some(serde_json::json!([{ "assertFunctionNames": ["tester.*.expect"] }]))),
+        ("test('should pass **', () => tester.foo().expect(123));", Some(serde_json::json!([{ "assertFunctionNames": ["**"] }]))),
+        ("test('should pass *', () => tester.foo().expect(123));", Some(serde_json::json!([{ "assertFunctionNames": ["*"] }]))),
+        ("test('should pass', () => tester.foo().expect(123));", Some(serde_json::json!([{ "assertFunctionNames": ["tester.**"] }]))),
+        ("test('should pass', () => tester.foo().expect(123));", Some(serde_json::json!([{ "assertFunctionNames": ["tester.*"] }]))),
+        ("test('should pass', () => tester.foo().bar().expectIt(456));", Some(serde_json::json!([{ "assertFunctionNames": ["tester.**.expect*"] }]))),
+        ("test('should pass', () => request.get().foo().expect(456));", Some(serde_json::json!([{ "assertFunctionNames": ["request.**.expect"] }]))),
+        ("test('should pass', () => request.get().foo().expect(456));", Some(serde_json::json!([{ "assertFunctionNames": ["request.**.e*e*t"] }]))),
         (
             "
         	import { test } from '@jest/globals';
diff --git a/crates/oxc_linter/src/rules/jest/max_expects.rs b/crates/oxc_linter/src/rules/jest/max_expects.rs
index b69a56f66a83..afc322327fbf 100644
--- a/crates/oxc_linter/src/rules/jest/max_expects.rs
+++ b/crates/oxc_linter/src/rules/jest/max_expects.rs
@@ -1,3 +1,5 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use std::{collections::HashMap, hash::BuildHasherDefault};
 
 use crate::{
@@ -6,23 +8,15 @@ use crate::{
     utils::{collect_possible_jest_call_node, PossibleJestNode},
 };
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use rustc_hash::{FxHashMap, FxHasher};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jest(max-expects): Enforces a maximum number assertion calls in a test body."
-)]
-#[diagnostic(
-    severity(warning),
-    help("Too many assertion calls ({0:?}) - maximum allowed is {1:?}")
-)]
-pub struct ExceededMaxAssertion(pub usize, pub usize, #[label] pub Span);
+fn exceeded_max_assertion(x0: usize, x1: usize, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(max-expects): Enforces a maximum number assertion calls in a test body.")
+        .with_help(format!("Too many assertion calls ({x0:?}) - maximum allowed is {x1:?}"))
+        .with_labels([span2.into()])
+}
 
 #[derive(Debug, Clone)]
 pub struct MaxExpects {
@@ -113,7 +107,7 @@ impl MaxExpects {
 
             if let Some(count) = count_map.get(&position) {
                 if count > &self.max {
-                    ctx.diagnostic(ExceededMaxAssertion(*count, self.max, ident.span));
+                    ctx.diagnostic(exceeded_max_assertion(*count, self.max, ident.span));
                 } else {
                     count_map.insert(position, count + 1);
                 }
diff --git a/crates/oxc_linter/src/rules/jest/no_alias_methods.rs b/crates/oxc_linter/src/rules/jest/no_alias_methods.rs
index 6e6eb1037501..b38089961a4c 100644
--- a/crates/oxc_linter/src/rules/jest/no_alias_methods.rs
+++ b/crates/oxc_linter/src/rules/jest/no_alias_methods.rs
@@ -1,8 +1,6 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -13,10 +11,11 @@ use crate::{
     utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-alias-methods): Unexpected alias {0:?}")]
-#[diagnostic(severity(warning), help("Replace {0:?} with its canonical name of {1:?}"))]
-struct NoAliasMethodsDiagnostic(pub &'static str, pub &'static str, #[label] pub Span);
+fn no_alias_methods_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jest(no-alias-methods): Unexpected alias {x0:?}"))
+        .with_help(format!("Replace {x0:?} with its canonical name of {x1:?}"))
+        .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAliasMethods;
@@ -82,7 +81,7 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
                 }
 
                 ctx.diagnostic_with_fix(
-                    NoAliasMethodsDiagnostic(name, canonical_name, matcher.span),
+                    no_alias_methods_diagnostic(name, canonical_name, matcher.span),
                     || Fix::new(canonical_name, Span::new(start, end)),
                 );
             }
diff --git a/crates/oxc_linter/src/rules/jest/no_commented_out_tests.rs b/crates/oxc_linter/src/rules/jest/no_commented_out_tests.rs
index 375d9dfddeb4..4a6bb05830f8 100644
--- a/crates/oxc_linter/src/rules/jest/no_commented_out_tests.rs
+++ b/crates/oxc_linter/src/rules/jest/no_commented_out_tests.rs
@@ -1,18 +1,19 @@
 use lazy_static::lazy_static;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use regex::Regex;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-commented-out-tests): Some tests seem to be commented")]
-#[diagnostic(severity(warning), help("Remove or uncomment this comment"))]
-struct NoCommentedOutTestsDiagnostic(#[label] pub Span);
+fn no_commented_out_tests_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-commented-out-tests): Some tests seem to be commented",
+    )
+    .with_help("Remove or uncomment this comment")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoCommentedOutTests;
@@ -62,7 +63,7 @@ impl Rule for NoCommentedOutTests {
         });
 
         for span in commented_tests {
-            ctx.diagnostic(NoCommentedOutTestsDiagnostic(span));
+            ctx.diagnostic(no_commented_out_tests_diagnostic(span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/jest/no_conditional_expect.rs b/crates/oxc_linter/src/rules/jest/no_conditional_expect.rs
index 2ef41084c6ad..56e6287f48df 100644
--- a/crates/oxc_linter/src/rules/jest/no_conditional_expect.rs
+++ b/crates/oxc_linter/src/rules/jest/no_conditional_expect.rs
@@ -1,10 +1,8 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use std::collections::HashMap;
 
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{AstNode, AstNodeId};
 use oxc_span::Span;
@@ -18,10 +16,13 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-conditional-expect): Unexpected conditional expect")]
-#[diagnostic(severity(warning), help("Avoid calling `expect` conditionally`"))]
-struct NoConditionalExpectDiagnostic(#[label] pub Span);
+fn no_conditional_expect_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-conditional-expect): Unexpected conditional expect",
+    )
+    .with_help("Avoid calling `expect` conditionally`")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoConditionalExpect;
@@ -84,7 +85,7 @@ fn run<'a>(
 
         let has_condition_or_catch = check_parents(node, id_nodes_mapping, ctx, false);
         if has_condition_or_catch {
-            ctx.diagnostic(NoConditionalExpectDiagnostic(jest_fn_call.head.span));
+            ctx.diagnostic(no_conditional_expect_diagnostic(jest_fn_call.head.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/jest/no_confusing_set_timeout.rs b/crates/oxc_linter/src/rules/jest/no_confusing_set_timeout.rs
index 77de4d93045e..f47ec38ab871 100644
--- a/crates/oxc_linter/src/rules/jest/no_confusing_set_timeout.rs
+++ b/crates/oxc_linter/src/rules/jest/no_confusing_set_timeout.rs
@@ -1,10 +1,8 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use std::collections::HashMap;
 
 use oxc_ast::{ast::MemberExpression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{AstNode, AstNodeId, ReferenceId};
 use oxc_span::{GetSpan, Span};
@@ -15,28 +13,23 @@ use crate::{
     utils::{collect_possible_jest_call_node, parse_jest_fn_call, PossibleJestNode},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-confusing-set-timeout)")]
-#[diagnostic(severity(warning), help("`jest.setTimeout` should be call in `global` scope"))]
-struct NoGlobalSetTimeoutDiagnostic(#[label] pub Span);
-
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-confusing-set-timeout)")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "Do not call `jest.setTimeout` multiple times, as only the last call will have an effect"
-    )
-)]
-struct NoMultipleSetTimeoutsDiagnostic(#[label] pub Span);
-
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-confusing-set-timeout)")]
-#[diagnostic(
-    severity(warning),
-    help("`jest.setTimeout` should be placed before any other jest methods")
-)]
-struct NoUnorderSetTimeoutDiagnostic(#[label] pub Span);
+fn no_global_set_timeout_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-confusing-set-timeout)")
+        .with_help("`jest.setTimeout` should be call in `global` scope")
+        .with_labels([span0.into()])
+}
+
+fn no_multiple_set_timeouts_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-confusing-set-timeout)")
+        .with_help("Do not call `jest.setTimeout` multiple times, as only the last call will have an effect")
+        .with_labels([span0.into()])
+}
+
+fn no_unorder_set_timeout_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-confusing-set-timeout)")
+        .with_help("`jest.setTimeout` should be placed before any other jest methods")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoConfusingSetTimeout;
@@ -173,7 +166,7 @@ fn handle_jest_set_time_out<'a>(
             if is_jest_fn_call(parent_node, id_to_jest_node_map, ctx) {
                 for (jest_reference_id, span) in jest_reference_id_list {
                     if jest_reference_id > &reference_id {
-                        ctx.diagnostic(NoUnorderSetTimeoutDiagnostic(*span));
+                        ctx.diagnostic(no_unorder_set_timeout_diagnostic(*span));
                     }
                 }
             }
@@ -190,11 +183,11 @@ fn handle_jest_set_time_out<'a>(
 
         if expr.property.name == "setTimeout" {
             if !scopes.get_flags(parent_node.scope_id()).is_top() {
-                ctx.diagnostic(NoGlobalSetTimeoutDiagnostic(member_expr.span()));
+                ctx.diagnostic(no_global_set_timeout_diagnostic(member_expr.span()));
             }
 
             if *seen_jest_set_timeout {
-                ctx.diagnostic(NoMultipleSetTimeoutsDiagnostic(member_expr.span()));
+                ctx.diagnostic(no_multiple_set_timeouts_diagnostic(member_expr.span()));
             } else {
                 *seen_jest_set_timeout = true;
             }
@@ -447,7 +440,7 @@ fn test() {
                 jest.setTimeout(800);
                 jest.setTimeout(900);
             ",
-            None
+            None,
         ),
         (
             "
diff --git a/crates/oxc_linter/src/rules/jest/no_deprecated_functions.rs b/crates/oxc_linter/src/rules/jest/no_deprecated_functions.rs
index 2cadbd68a519..a6f8626428d0 100644
--- a/crates/oxc_linter/src/rules/jest/no_deprecated_functions.rs
+++ b/crates/oxc_linter/src/rules/jest/no_deprecated_functions.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use phf::{phf_map, Map};
@@ -10,10 +8,13 @@ use std::borrow::Cow;
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-deprecated-functions): Disallow use of deprecated functions")]
-#[diagnostic(severity(warning), help("{0:?} has been deprecated in favor of {1:?}"))]
-pub struct DeprecatedFunction(pub String, pub String, #[label] pub Span);
+fn deprecated_function(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-deprecated-functions): Disallow use of deprecated functions",
+    )
+    .with_help(format!("{x0:?} has been deprecated in favor of {x1:?}"))
+    .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct JestConfig {
@@ -127,7 +128,7 @@ impl Rule for NoDeprecatedFunctions {
         if let Some((base_version, replacement)) = DEPRECATED_FUNCTIONS_MAP.get(&node_name) {
             if jest_version_num >= *base_version {
                 ctx.diagnostic_with_fix(
-                    DeprecatedFunction(node_name, (*replacement).to_string(), mem_expr.span()),
+                    deprecated_function(&node_name, replacement, mem_expr.span()),
                     || Fix::new(*replacement, mem_expr.span()),
                 );
             }
diff --git a/crates/oxc_linter/src/rules/jest/no_disabled_tests.rs b/crates/oxc_linter/src/rules/jest/no_disabled_tests.rs
index 06e416df5e30..eb03a57c98c3 100644
--- a/crates/oxc_linter/src/rules/jest/no_disabled_tests.rs
+++ b/crates/oxc_linter/src/rules/jest/no_disabled_tests.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -55,10 +53,11 @@ declare_oxc_lint!(
     correctness
 );
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-disabled-tests): {0:?}")]
-#[diagnostic(severity(warning), help("{1:?}"))]
-struct NoDisabledTestsDiagnostic(&'static str, &'static str, #[label] pub Span);
+fn no_disabled_tests_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jest(no-disabled-tests): {x0:?}"))
+        .with_help(format!("{x1:?}"))
+        .with_labels([span2.into()])
+}
 
 enum Message {
     MissingFunction,
@@ -105,7 +104,7 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
                 && members.iter().all(|member| member.is_name_unequal("todo"))
             {
                 let (error, help) = Message::MissingFunction.details();
-                ctx.diagnostic(NoDisabledTestsDiagnostic(error, help, call_expr.span));
+                ctx.diagnostic(no_disabled_tests_diagnostic(error, help, call_expr.span));
                 return;
             }
 
@@ -117,7 +116,7 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
                 } else {
                     Message::DisabledTestWithX.details()
                 };
-                ctx.diagnostic(NoDisabledTestsDiagnostic(error, help, call_expr.callee.span()));
+                ctx.diagnostic(no_disabled_tests_diagnostic(error, help, call_expr.callee.span()));
                 return;
             }
 
@@ -129,7 +128,7 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
                 } else {
                     Message::DisabledTestWithSkip.details()
                 };
-                ctx.diagnostic(NoDisabledTestsDiagnostic(error, help, call_expr.callee.span()));
+                ctx.diagnostic(no_disabled_tests_diagnostic(error, help, call_expr.callee.span()));
             }
         } else if let Expression::Identifier(ident) = &call_expr.callee {
             if ident.name.as_str() == "pending"
@@ -137,7 +136,7 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
             {
                 // `describe('foo', function () { pending() })`
                 let (error, help) = Message::Pending.details();
-                ctx.diagnostic(NoDisabledTestsDiagnostic(error, help, call_expr.span));
+                ctx.diagnostic(no_disabled_tests_diagnostic(error, help, call_expr.span));
             }
         }
     }
@@ -167,22 +166,10 @@ fn test() {
         ("testSomething()", None),
         ("xitSomethingElse()", None),
         ("xitiViewMap()", None),
-        (
-            "import { pending } from 'actions'; test('foo', () => { expect(pending()).toEqual({}) })",
-            None,
-        ),
-        (
-            "const { pending } = require('actions'); test('foo', () => { expect(pending()).toEqual({}) })",
-            None,
-        ),
-        (
-            "test('foo', () => { const pending = getPending(); expect(pending()).toEqual({}) })",
-            None,
-        ),
-        (
-            "test('foo', () => { expect(pending()).toEqual({}) }); function pending() { return {} }",
-            None,
-        ),
+        ("import { pending } from 'actions'; test('foo', () => { expect(pending()).toEqual({}) })", None),
+        ("const { pending } = require('actions'); test('foo', () => { expect(pending()).toEqual({}) })", None),
+        ("test('foo', () => { const pending = getPending(); expect(pending()).toEqual({}) })", None),
+        ("test('foo', () => { expect(pending()).toEqual({}) }); function pending() { return {} }", None),
         ("import { test } from './test-utils'; test('something');", None),
     ];
 
diff --git a/crates/oxc_linter/src/rules/jest/no_done_callback.rs b/crates/oxc_linter/src/rules/jest/no_done_callback.rs
index c2ac21378de4..381e57e50a36 100644
--- a/crates/oxc_linter/src/rules/jest/no_done_callback.rs
+++ b/crates/oxc_linter/src/rules/jest/no_done_callback.rs
@@ -2,10 +2,7 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression, FormalParameters},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -18,18 +15,20 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoDoneCallbackDiagnostic {
-    #[error("eslint-plugin-jest(no-done-callback): Function parameter(s) use the `done` argument")]
-    #[diagnostic(
-        severity(warning),
-        help("Return a Promise instead of relying on callback parameter")
-    )]
-    NoDoneCallback(#[label] Span),
+fn no_done_callback(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-done-callback): Function parameter(s) use the `done` argument",
+    )
+    .with_help("Return a Promise instead of relying on callback parameter")
+    .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-jest(no-done-callback): Function parameter(s) use the `done` argument")]
-    #[diagnostic(severity(warning), help("Use await instead of callback in async functions"))]
-    UseAwaitInsteadOfCallback(#[label] Span),
+fn use_await_instead_of_callback(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-done-callback): Function parameter(s) use the `done` argument",
+    )
+    .with_help("Use await instead of callback in async functions")
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -127,11 +126,11 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
                     };
 
                     if func_expr.r#async {
-                        ctx.diagnostic(NoDoneCallbackDiagnostic::UseAwaitInsteadOfCallback(span));
+                        ctx.diagnostic(use_await_instead_of_callback(span));
                         return;
                     }
 
-                    ctx.diagnostic(NoDoneCallbackDiagnostic::NoDoneCallback(span));
+                    ctx.diagnostic(no_done_callback(span));
                 }
                 Argument::ArrowFunctionExpression(arrow_expr) => {
                     if arrow_expr.params.parameters_count() != 1 + callback_arg_index {
@@ -143,11 +142,11 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
                     };
 
                     if arrow_expr.r#async {
-                        ctx.diagnostic(NoDoneCallbackDiagnostic::UseAwaitInsteadOfCallback(span));
+                        ctx.diagnostic(use_await_instead_of_callback(span));
                         return;
                     }
 
-                    ctx.diagnostic(NoDoneCallbackDiagnostic::NoDoneCallback(span));
+                    ctx.diagnostic(no_done_callback(span));
                 }
                 _ => {}
             }
diff --git a/crates/oxc_linter/src/rules/jest/no_export.rs b/crates/oxc_linter/src/rules/jest/no_export.rs
index 565b7b70645c..991468b76e24 100644
--- a/crates/oxc_linter/src/rules/jest/no_export.rs
+++ b/crates/oxc_linter/src/rules/jest/no_export.rs
@@ -1,16 +1,15 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, utils::is_jest_file};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-export): Do not export from a test file.")]
-#[diagnostic(severity(warning), help("If you want to share code between tests, move it into a separate file and import it from there."))]
-struct NoExportDiagnostic(#[label] pub Span);
+fn no_export_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-export): Do not export from a test file.")
+        .with_help("If you want to share code between tests, move it into a separate file and import it from there.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoExport;
@@ -45,11 +44,11 @@ impl Rule for NoExport {
         }
 
         for span in ctx.semantic().module_record().exported_bindings.values() {
-            ctx.diagnostic(NoExportDiagnostic(*span));
+            ctx.diagnostic(no_export_diagnostic(*span));
         }
 
         if let Some(span) = ctx.semantic().module_record().export_default {
-            ctx.diagnostic(NoExportDiagnostic(span));
+            ctx.diagnostic(no_export_diagnostic(span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/jest/no_focused_tests.rs b/crates/oxc_linter/src/rules/jest/no_focused_tests.rs
index 344749b11585..41ee97a2a3b5 100644
--- a/crates/oxc_linter/src/rules/jest/no_focused_tests.rs
+++ b/crates/oxc_linter/src/rules/jest/no_focused_tests.rs
@@ -1,8 +1,6 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,10 +14,11 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-focused-tests): Unexpected focused test.")]
-#[diagnostic(severity(warning), help("Remove focus from test."))]
-struct NoFocusedTestsDiagnostic(#[label] pub Span);
+fn no_focused_tests_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-focused-tests): Unexpected focused test.")
+        .with_help("Remove focus from test.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoFocusedTests;
@@ -66,7 +65,9 @@ impl Rule for NoFocusedTests {
 
 fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>) {
     let node = possible_jest_node.node;
-    let AstKind::CallExpression(call_expr) = node.kind() else { return };
+    let AstKind::CallExpression(call_expr) = node.kind() else {
+        return;
+    };
     let Some(jest_fn_call) = parse_general_jest_fn_call(call_expr, possible_jest_node, ctx) else {
         return;
     };
@@ -76,7 +77,7 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
     }
 
     if name.starts_with('f') {
-        ctx.diagnostic_with_fix(NoFocusedTestsDiagnostic(call_expr.span), || {
+        ctx.diagnostic_with_fix(no_focused_tests_diagnostic(call_expr.span), || {
             let start = call_expr.span.start;
             Fix::delete(Span::new(start, start + 1))
         });
@@ -86,7 +87,7 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
 
     let only_node = members.iter().find(|member| member.is_name_equal("only"));
     if let Some(only_node) = only_node {
-        ctx.diagnostic_with_fix(NoFocusedTestsDiagnostic(call_expr.span), || {
+        ctx.diagnostic_with_fix(no_focused_tests_diagnostic(call_expr.span), || {
             let span = only_node.span;
             let start = span.start - 1;
             let end = if matches!(only_node.element, MemberExpressionElement::IdentName(_)) {
diff --git a/crates/oxc_linter/src/rules/jest/no_hooks.rs b/crates/oxc_linter/src/rules/jest/no_hooks.rs
index 0e3fa9705e9a..b974bec2257b 100644
--- a/crates/oxc_linter/src/rules/jest/no_hooks.rs
+++ b/crates/oxc_linter/src/rules/jest/no_hooks.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -15,10 +13,10 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-hooks): Disallow setup and teardown hooks.")]
-#[diagnostic(severity(warning))]
-pub struct UnexpectedHookDiagonsitc(#[label] pub Span);
+fn unexpected_hook_diagonsitc(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-hooks): Disallow setup and teardown hooks.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoHooks(Box<NoHooksConfig>);
@@ -122,7 +120,7 @@ impl NoHooks {
 
         if let Expression::Identifier(ident) = &call_expr.callee {
             if !self.allow.contains(&ident.name.to_string()) {
-                ctx.diagnostic(UnexpectedHookDiagonsitc(call_expr.callee.span()));
+                ctx.diagnostic(unexpected_hook_diagonsitc(call_expr.callee.span()));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jest/no_identical_title.rs b/crates/oxc_linter/src/rules/jest/no_identical_title.rs
index db433bd4e9d3..96451c5d8b56 100644
--- a/crates/oxc_linter/src/rules/jest/no_identical_title.rs
+++ b/crates/oxc_linter/src/rules/jest/no_identical_title.rs
@@ -4,10 +4,7 @@ use oxc_ast::{
     ast::{Argument, CallExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNodeId;
 use oxc_span::{Atom, Span};
@@ -22,15 +19,14 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoIdenticalTitleDiagnostic {
-    #[error("eslint-plugin-jest(no-identical-title): Describe block title is used multiple times in the same describe block.")]
-    #[diagnostic(severity(warning), help("Change the title of describe block."))]
-    DescribeRepeat(#[label] Span),
+fn describe_repeat(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-identical-title): Describe block title is used multiple times in the same describe block.")
+        .with_help("Change the title of describe block.")
+        .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-jest(no-identical-title): Test title is used multiple times in the same describe block.")]
-    #[diagnostic(severity(warning), help("Change the title of test."))]
-    TestRepeat(#[label] Span),
+fn test_repeat(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-identical-title): Test title is used multiple times in the same describe block.").with_help("Change the title of test.").with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -103,10 +99,10 @@ impl Rule for NoIdenticalTitle {
                 if kind == prev_kind && parent_id == prev_parent {
                     match kind {
                         JestFnKind::General(JestGeneralFnKind::Describe) => {
-                            ctx.diagnostic(NoIdenticalTitleDiagnostic::DescribeRepeat(span));
+                            ctx.diagnostic(describe_repeat(span));
                         }
                         JestFnKind::General(JestGeneralFnKind::Test) => {
-                            ctx.diagnostic(NoIdenticalTitleDiagnostic::TestRepeat(span));
+                            ctx.diagnostic(test_repeat(span));
                         }
                         _ => {}
                     }
diff --git a/crates/oxc_linter/src/rules/jest/no_interpolation_in_snapshots.rs b/crates/oxc_linter/src/rules/jest/no_interpolation_in_snapshots.rs
index 017f9cdc8d44..0435cd165b03 100644
--- a/crates/oxc_linter/src/rules/jest/no_interpolation_in_snapshots.rs
+++ b/crates/oxc_linter/src/rules/jest/no_interpolation_in_snapshots.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::Argument, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -12,10 +10,11 @@ use crate::{
     utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-interpolation-in-snapshots): Do not use string interpolation inside of snapshots")]
-#[diagnostic(severity(warning), help("Remove string interpolation from snapshots"))]
-struct NoInterpolationInSnapshotsDiagnostic(#[label] pub Span);
+fn no_interpolation_in_snapshots_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-interpolation-in-snapshots): Do not use string interpolation inside of snapshots")
+        .with_help("Remove string interpolation from snapshots")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoInterpolationInSnapshots;
@@ -66,7 +65,9 @@ impl Rule for NoInterpolationInSnapshots {
 
 fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>) {
     let node = possible_jest_node.node;
-    let AstKind::CallExpression(call_expr) = node.kind() else { return };
+    let AstKind::CallExpression(call_expr) = node.kind() else {
+        return;
+    };
     let Some(jest_fn_call) = parse_expect_jest_fn_call(call_expr, possible_jest_node, ctx) else {
         return;
     };
@@ -85,7 +86,7 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
     for arg in jest_fn_call.args {
         if let Argument::TemplateLiteral(template_lit) = arg {
             if !template_lit.expressions.is_empty() {
-                ctx.diagnostic(NoInterpolationInSnapshotsDiagnostic(template_lit.span));
+                ctx.diagnostic(no_interpolation_in_snapshots_diagnostic(template_lit.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jest/no_jasmine_globals.rs b/crates/oxc_linter/src/rules/jest/no_jasmine_globals.rs
index 1add8186a056..cae309555a8f 100644
--- a/crates/oxc_linter/src/rules/jest/no_jasmine_globals.rs
+++ b/crates/oxc_linter/src/rules/jest/no_jasmine_globals.rs
@@ -4,19 +4,18 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-jasmine-globals): {0:?}")]
-#[diagnostic(severity(warning), help("{1:?}"))]
-struct NoJasmineGlobalsDiagnostic(pub &'static str, pub &'static str, #[label] pub Span);
+fn no_jasmine_globals_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jest(no-jasmine-globals): {x0:?}"))
+        .with_help(format!("{x1:?}"))
+        .with_labels([span2.into()])
+}
 
 /// <https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/no-jasmine-globals.md>
 #[derive(Debug, Default, Clone)]
@@ -58,7 +57,7 @@ impl Rule for NoJasmineGlobals {
             for &reference_id in reference_ids {
                 let reference = symbol_table.get_reference(reference_id);
                 if let Some((error, help)) = get_non_jasmine_property_messages(name) {
-                    ctx.diagnostic(NoJasmineGlobalsDiagnostic(error, help, reference.span()));
+                    ctx.diagnostic(no_jasmine_globals_diagnostic(error, help, reference.span()));
                 }
             }
         }
@@ -79,13 +78,15 @@ fn diagnostic_assign_expr<'a>(expr: &'a AssignmentExpression<'a>, ctx: &LintCont
         .as_simple_assignment_target()
         .and_then(SimpleAssignmentTarget::as_member_expression)
     {
-        let Some((span, property_name)) = get_jasmine_property_name(member_expr) else { return };
+        let Some((span, property_name)) = get_jasmine_property_name(member_expr) else {
+            return;
+        };
 
         if property_name == "DEFAULT_TIMEOUT_INTERVAL" {
             // `jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000` we can fix it to `jest.setTimeout(5000)`
             if let Expression::NumericLiteral(number_literal) = &expr.right {
                 ctx.diagnostic_with_fix(
-                    NoJasmineGlobalsDiagnostic(COMMON_ERROR_TEXT, COMMON_HELP_TEXT, span),
+                    no_jasmine_globals_diagnostic(COMMON_ERROR_TEXT, COMMON_HELP_TEXT, span),
                     || {
                         let content = format!("jest.setTimeout({})", number_literal.value);
                         Fix::new(content, expr.span)
@@ -95,17 +96,19 @@ fn diagnostic_assign_expr<'a>(expr: &'a AssignmentExpression<'a>, ctx: &LintCont
             }
         }
 
-        ctx.diagnostic(NoJasmineGlobalsDiagnostic(COMMON_ERROR_TEXT, COMMON_HELP_TEXT, span));
+        ctx.diagnostic(no_jasmine_globals_diagnostic(COMMON_ERROR_TEXT, COMMON_HELP_TEXT, span));
     }
 }
 
 fn diagnostic_call_expr<'a>(expr: &'a CallExpression<'a>, ctx: &LintContext) {
     if let Some(member_expr) = expr.callee.as_member_expression() {
-        let Some((span, property_name)) = get_jasmine_property_name(member_expr) else { return };
+        let Some((span, property_name)) = get_jasmine_property_name(member_expr) else {
+            return;
+        };
 
         JasmineProperty::from_str(property_name).map_or_else(
             || {
-                ctx.diagnostic(NoJasmineGlobalsDiagnostic(
+                ctx.diagnostic(no_jasmine_globals_diagnostic(
                     COMMON_ERROR_TEXT,
                     COMMON_HELP_TEXT,
                     span,
@@ -114,11 +117,12 @@ fn diagnostic_call_expr<'a>(expr: &'a CallExpression<'a>, ctx: &LintContext) {
             |jasmine_property| {
                 let (error, help) = jasmine_property.details();
                 if jasmine_property.available_in_jest_expect() {
-                    ctx.diagnostic_with_fix(NoJasmineGlobalsDiagnostic(error, help, span), || {
-                        Fix::new("expect", member_expr.object().span())
-                    });
+                    ctx.diagnostic_with_fix(
+                        no_jasmine_globals_diagnostic(error, help, span),
+                        || Fix::new("expect", member_expr.object().span()),
+                    );
                 } else {
-                    ctx.diagnostic(NoJasmineGlobalsDiagnostic(error, help, span));
+                    ctx.diagnostic(no_jasmine_globals_diagnostic(error, help, span));
                 }
             },
         );
diff --git a/crates/oxc_linter/src/rules/jest/no_mocks_import.rs b/crates/oxc_linter/src/rules/jest/no_mocks_import.rs
index 11454c5e339e..fe9bea6e397d 100644
--- a/crates/oxc_linter/src/rules/jest/no_mocks_import.rs
+++ b/crates/oxc_linter/src/rules/jest/no_mocks_import.rs
@@ -1,22 +1,18 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use std::path::PathBuf;
 
 use oxc_ast::{ast::Argument, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-mocks-import): Mocks should not be manually imported from a `__mocks__` directory.")]
-#[diagnostic(
-    severity(warning),
-    help("Instead use `jest.mock` and import from the original module path.")
-)]
-struct NoMocksImportDiagnostic(#[label] pub Span);
+fn no_mocks_import_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-mocks-import): Mocks should not be manually imported from a `__mocks__` directory.")
+        .with_help("Instead use `jest.mock` and import from the original module path.")
+        .with_labels([span0.into()])
+}
 
 /// <https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/no-mocks-import.md>
 #[derive(Debug, Default, Clone)]
@@ -44,7 +40,7 @@ impl Rule for NoMocksImport {
         for import_entry in &module_records.import_entries {
             let module_specifier = import_entry.module_request.name().as_str();
             if contains_mocks_dir(module_specifier) {
-                ctx.diagnostic(NoMocksImportDiagnostic(import_entry.module_request.span()));
+                ctx.diagnostic(no_mocks_import_diagnostic(import_entry.module_request.span()));
             }
         }
 
@@ -67,7 +63,7 @@ impl Rule for NoMocksImport {
             };
 
             if contains_mocks_dir(&string_literal.value) {
-                ctx.diagnostic(NoMocksImportDiagnostic(string_literal.span));
+                ctx.diagnostic(no_mocks_import_diagnostic(string_literal.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jest/no_restricted_jest_methods.rs b/crates/oxc_linter/src/rules/jest/no_restricted_jest_methods.rs
index 2d2a4e188532..598652167cb4 100644
--- a/crates/oxc_linter/src/rules/jest/no_restricted_jest_methods.rs
+++ b/crates/oxc_linter/src/rules/jest/no_restricted_jest_methods.rs
@@ -8,23 +8,26 @@ use crate::{
 };
 
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use rustc_hash::{FxHashMap, FxHasher};
 use std::{collections::HashMap, hash::BuildHasherDefault};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoRestrictedJestMethodsDiagnostic {
-    #[error("eslint-plugin-jest(no-restricted-jest-methods): Disallow specific `jest.` methods")]
-    #[diagnostic(severity(warning), help("Use of `{0:?}` is disallowed"))]
-    RestrictedJestMethod(String, #[label] Span),
-    #[error("eslint-plugin-jest(no-restricted-jest-methods): Disallow specific `jest.` methods")]
-    #[diagnostic(severity(warning), help("{0:?}"))]
-    RestrictedJestMethodWithMessage(String, #[label] Span),
+fn restricted_jest_method(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-restricted-jest-methods): Disallow specific `jest.` methods",
+    )
+    .with_help(format!("Use of `{x0:?}` is disallowed"))
+    .with_labels([span1.into()])
+}
+
+fn restricted_jest_method_with_message(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-restricted-jest-methods): Disallow specific `jest.` methods",
+    )
+    .with_help(format!("{x0:?}"))
+    .with_labels([span1.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -126,23 +129,13 @@ impl NoRestrictedJestMethods {
         if self.contains(property_name) {
             self.get_message(property_name).map_or_else(
                 || {
-                    ctx.diagnostic(NoRestrictedJestMethodsDiagnostic::RestrictedJestMethod(
-                        property_name.to_string(),
-                        span,
-                    ));
+                    ctx.diagnostic(restricted_jest_method(property_name, span));
                 },
                 |message| {
                     if message.trim() == "" {
-                        ctx.diagnostic(NoRestrictedJestMethodsDiagnostic::RestrictedJestMethod(
-                            property_name.to_string(),
-                            span,
-                        ));
+                        ctx.diagnostic(restricted_jest_method(property_name, span));
                     } else {
-                        ctx.diagnostic(
-                            NoRestrictedJestMethodsDiagnostic::RestrictedJestMethodWithMessage(
-                                message, span,
-                            ),
-                        );
+                        ctx.diagnostic(restricted_jest_method_with_message(&message, span));
                     }
                 },
             );
diff --git a/crates/oxc_linter/src/rules/jest/no_restricted_matchers.rs b/crates/oxc_linter/src/rules/jest/no_restricted_matchers.rs
index 4efaedc1e3df..987c2307e3d8 100644
--- a/crates/oxc_linter/src/rules/jest/no_restricted_matchers.rs
+++ b/crates/oxc_linter/src/rules/jest/no_restricted_matchers.rs
@@ -8,24 +8,27 @@ use crate::{
 };
 
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::phf_set;
 use rustc_hash::{FxHashMap, FxHasher};
 use std::{collections::HashMap, hash::BuildHasherDefault, path::Path};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoRestrictedMatchersDiagnostic {
-    #[error("eslint-plugin-jest(no-restricted-matchers): Disallow specific matchers & modifiers")]
-    #[diagnostic(severity(warning), help("Use of `{0:?}` is disallowed`"))]
-    RestrictedChain(String, #[label] Span),
-    #[error("eslint-plugin-jest(no-restricted-matchers): Disallow specific matchers & modifiers")]
-    #[diagnostic(severity(warning), help("{0:?}"))]
-    RestrictedChainWithMessage(String, #[label] Span),
+fn restricted_chain(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-restricted-matchers): Disallow specific matchers & modifiers",
+    )
+    .with_help(format!("Use of `{x0:?}` is disallowed`"))
+    .with_labels([span1.into()])
+}
+
+fn restricted_chain_with_message(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-restricted-matchers): Disallow specific matchers & modifiers",
+    )
+    .with_help(format!("{x0:?}"))
+    .with_labels([span1.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -128,15 +131,9 @@ impl NoRestrictedMatchers {
         for (restriction, message) in &self.restricted_matchers {
             if Self::check_restriction(chain_call.as_str(), restriction.as_str()) {
                 if message.is_empty() {
-                    ctx.diagnostic(NoRestrictedMatchersDiagnostic::RestrictedChain(
-                        chain_call.clone(),
-                        span,
-                    ));
+                    ctx.diagnostic(restricted_chain(&chain_call, span));
                 } else {
-                    ctx.diagnostic(NoRestrictedMatchersDiagnostic::RestrictedChainWithMessage(
-                        message.to_string(),
-                        span,
-                    ));
+                    ctx.diagnostic(restricted_chain_with_message(message, span));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/jest/no_standalone_expect.rs b/crates/oxc_linter/src/rules/jest/no_standalone_expect.rs
index 020427e0ab7c..adf9c2dfb584 100644
--- a/crates/oxc_linter/src/rules/jest/no_standalone_expect.rs
+++ b/crates/oxc_linter/src/rules/jest/no_standalone_expect.rs
@@ -1,10 +1,8 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use std::collections::HashMap;
 
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNodeId;
 use oxc_span::Span;
@@ -20,10 +18,13 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-standalone-expect): Expect must be inside of a test block.")]
-#[diagnostic(severity(warning), help("Did you forget to wrap `expect` in a `test` or `it` block?"))]
-struct NoStandaloneExpectDiagnostic(#[label] pub Span);
+fn no_standalone_expect_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-standalone-expect): Expect must be inside of a test block.",
+    )
+    .with_help("Did you forget to wrap `expect` in a `test` or `it` block?")
+    .with_labels([span0.into()])
+}
 
 /// <https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/no-standalone-expect.md>
 #[derive(Debug, Default, Clone)]
@@ -122,7 +123,7 @@ impl NoStandaloneExpect {
         )
         .is_none()
         {
-            ctx.diagnostic(NoStandaloneExpectDiagnostic(head.span));
+            ctx.diagnostic(no_standalone_expect_diagnostic(head.span));
         }
     }
 }
@@ -261,17 +262,20 @@ fn test() {
                     expect(value).toBe(true);
                 });
             ",
-            None
+            None,
         ),
         ("it.only('an only', value => { expect(value).toBe(true); });", None),
         ("it.concurrent('an concurrent', value => { expect(value).toBe(true); });", None),
         ("describe.each([1, true])('trues', value => { it('an it', () => expect(value).toBe(true) ); });", None),
-        ("
+        (
+            "
             describe('scenario', () => {
                 const t = Math.random() ? it.only : it;
                 t('testing', () => expect(true));
             });
-        ", Some(serde_json::json!([{ "additionalTestBlockFunctions": ['t'] }]))),
+        ",
+            Some(serde_json::json!([{ "additionalTestBlockFunctions": ['t'] }])),
+        ),
         (
             r"
                 each([
@@ -281,8 +285,10 @@ fn test() {
                 ]).test('returns the result of adding %d to %d', (a, b, expected) => {
                     expect(a + b).toBe(expected);
                 });
-            ", Some(serde_json::json!([{ "additionalTestBlockFunctions": ["each.test"] }])))
-        ];
+            ",
+            Some(serde_json::json!([{ "additionalTestBlockFunctions": ["each.test"] }])),
+        ),
+    ];
 
     let fail = vec![
         ("(() => {})('testing', () => expect(true).toBe(false))", None),
@@ -295,7 +301,7 @@ fn test() {
                     t('testing', () => expect(true).toBe(false));
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -304,7 +310,7 @@ fn test() {
                     t('testing', () => expect(true).toBe(false));
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -315,7 +321,9 @@ fn test() {
                 ]).test('returns the result of adding %d to %d', (a, b, expected) => {
                     expect(a + b).toBe(expected);
                 });
-            ", None),
+            ",
+            None,
+        ),
         (
             "
                 each([
@@ -326,7 +334,7 @@ fn test() {
                     expect(a + b).toBe(expected);
                 });
             ",
-            Some(serde_json::json!([{ "additionalTestBlockFunctions": ["each"] }]))
+            Some(serde_json::json!([{ "additionalTestBlockFunctions": ["each"] }])),
         ),
         (
             "
@@ -338,7 +346,7 @@ fn test() {
                     expect(a + b).toBe(expected);
                 });
             ",
-            Some(serde_json::json!([{ "additionalTestBlockFunctions": ["test"] }]))
+            Some(serde_json::json!([{ "additionalTestBlockFunctions": ["test"] }])),
         ),
         ("describe('a test', () => { expect(1).toBe(1); });", None),
         ("describe('a test', () => expect(1).toBe(1));", None),
@@ -353,15 +361,15 @@ fn test() {
                 import { expect as pleaseExpect } from '@jest/globals';
                 describe('a test', () => { pleaseExpect(1).toBe(1); });
             ",
-            None
+            None,
         ),
         (
             "
                 import { expect as pleaseExpect } from '@jest/globals';
                 beforeEach(() => pleaseExpect.hasAssertions());
             ",
-            None
-        )
+            None,
+        ),
     ];
 
     Tester::new(NoStandaloneExpect::NAME, pass, fail).with_jest_plugin(true).test_and_snapshot();
diff --git a/crates/oxc_linter/src/rules/jest/no_test_prefixes.rs b/crates/oxc_linter/src/rules/jest/no_test_prefixes.rs
index 3b95fdfef296..a4e2e4a5aa42 100644
--- a/crates/oxc_linter/src/rules/jest/no_test_prefixes.rs
+++ b/crates/oxc_linter/src/rules/jest/no_test_prefixes.rs
@@ -1,10 +1,8 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, GetSpan, Span};
+use oxc_span::{GetSpan, Span};
 
 use crate::{
     context::LintContext,
@@ -16,10 +14,10 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-test-prefixes): Use {0:?} instead.")]
-#[diagnostic(severity(warning))]
-struct NoTestPrefixesDiagnostic(CompactStr, #[label] pub Span);
+fn no_test_prefixes_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jest(no-test-prefixes): Use {x0:?} instead."))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoTestPrefixes;
@@ -60,12 +58,16 @@ impl Rule for NoTestPrefixes {
 
 fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>) {
     let node = possible_jest_node.node;
-    let AstKind::CallExpression(call_expr) = node.kind() else { return };
+    let AstKind::CallExpression(call_expr) = node.kind() else {
+        return;
+    };
     let Some(jest_fn_call) = parse_general_jest_fn_call(call_expr, possible_jest_node, ctx) else {
         return;
     };
     let ParsedGeneralJestFnCall { kind, name, .. } = &jest_fn_call;
-    let Some(kind) = kind.to_general() else { return };
+    let Some(kind) = kind.to_general() else {
+        return;
+    };
 
     if !matches!(kind, JestGeneralFnKind::Describe | JestGeneralFnKind::Test) {
         return;
@@ -84,14 +86,13 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
     };
 
     let preferred_node_name = get_preferred_node_names(&jest_fn_call);
-    let preferred_node_name_cloned = preferred_node_name.clone();
 
-    ctx.diagnostic_with_fix(NoTestPrefixesDiagnostic(preferred_node_name, span), || {
-        Fix::new(preferred_node_name_cloned.to_string(), span)
+    ctx.diagnostic_with_fix(no_test_prefixes_diagnostic(&preferred_node_name, span), || {
+        Fix::new(preferred_node_name, span)
     });
 }
 
-fn get_preferred_node_names(jest_fn_call: &ParsedGeneralJestFnCall) -> CompactStr {
+fn get_preferred_node_names(jest_fn_call: &ParsedGeneralJestFnCall) -> String {
     let ParsedGeneralJestFnCall { members, name, .. } = jest_fn_call;
 
     let preferred_modifier = if name.starts_with('f') { "only" } else { "skip" };
@@ -103,9 +104,9 @@ fn get_preferred_node_names(jest_fn_call: &ParsedGeneralJestFnCall) -> CompactSt
     let name_slice = &name[1..];
 
     if member_names.is_empty() {
-        CompactStr::from(format!("{name_slice}.{preferred_modifier}"))
+        format!("{name_slice}.{preferred_modifier}")
     } else {
-        CompactStr::from(format!("{name_slice}.{preferred_modifier}.{member_names}"))
+        format!("{name_slice}.{preferred_modifier}.{member_names}")
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/jest/no_test_return_statement.rs b/crates/oxc_linter/src/rules/jest/no_test_return_statement.rs
index 3223bae3136e..d59849a27ad6 100644
--- a/crates/oxc_linter/src/rules/jest/no_test_return_statement.rs
+++ b/crates/oxc_linter/src/rules/jest/no_test_return_statement.rs
@@ -3,24 +3,23 @@ use crate::{
     rule::Rule,
     utils::{is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind, PossibleJestNode},
 };
+use oxc_diagnostics::OxcDiagnostic;
 
 use oxc_allocator::Box as OBox;
 use oxc_ast::{
     ast::{CallExpression, Expression, FunctionBody, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNode;
 use oxc_span::{GetSpan, Span};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-test-return-statement): Jest tests should not return a value")]
-#[diagnostic(severity(warning))]
-pub struct NoTestReturnStatementDiagnostic(#[label] pub Span);
+fn no_test_return_statement_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(no-test-return-statement): Jest tests should not return a value",
+    )
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoTestReturnStatement;
@@ -120,7 +119,7 @@ fn check_test_return_statement<'a>(func_body: &OBox<'_, FunctionBody<'a>>, ctx:
         return;
     }
 
-    ctx.diagnostic(NoTestReturnStatementDiagnostic(Span::new(
+    ctx.diagnostic(no_test_return_statement_diagnostic(Span::new(
         return_stmt.span().start,
         call_expr.span.start - 1,
     )));
diff --git a/crates/oxc_linter/src/rules/jest/no_untyped_mock_factory.rs b/crates/oxc_linter/src/rules/jest/no_untyped_mock_factory.rs
index 3943dcbe89f8..1faa53989a84 100644
--- a/crates/oxc_linter/src/rules/jest/no_untyped_mock_factory.rs
+++ b/crates/oxc_linter/src/rules/jest/no_untyped_mock_factory.rs
@@ -4,25 +4,20 @@ use crate::{
     rule::Rule,
     utils::{collect_possible_jest_call_node, PossibleJestNode},
 };
+use oxc_diagnostics::OxcDiagnostic;
 
 use oxc_ast::{
     ast::{Argument, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(no-untyped-mock-factory): Disallow using `jest.mock()` factories without an explicit type parameter.")]
-#[diagnostic(
-    severity(warning),
-    help("Add a type parameter to the mock factory such as `typeof import({0:?})`")
-)]
-struct AddTypeParameterToModuleMockDiagnostic(CompactStr, #[label] pub Span);
+fn add_type_parameter_to_module_mock_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(no-untyped-mock-factory): Disallow using `jest.mock()` factories without an explicit type parameter.")
+        .with_help(format!("Add a type parameter to the mock factory such as `typeof import({x0:?})`"))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUntypedMockFactory;
@@ -141,8 +136,8 @@ impl NoUntypedMockFactory {
 
         if let Expression::StringLiteral(string_literal) = expr {
             ctx.diagnostic_with_fix(
-                AddTypeParameterToModuleMockDiagnostic(
-                    string_literal.value.to_compact_str(),
+                add_type_parameter_to_module_mock_diagnostic(
+                    string_literal.value.as_str(),
                     property_span,
                 ),
                 || {
@@ -158,8 +153,8 @@ impl NoUntypedMockFactory {
                 },
             );
         } else if let Expression::Identifier(ident) = expr {
-            ctx.diagnostic(AddTypeParameterToModuleMockDiagnostic(
-                ident.name.to_compact_str(),
+            ctx.diagnostic(add_type_parameter_to_module_mock_diagnostic(
+                ident.name.as_str(),
                 property_span,
             ));
         }
diff --git a/crates/oxc_linter/src/rules/jest/prefer_called_with.rs b/crates/oxc_linter/src/rules/jest/prefer_called_with.rs
index 7b290f5faba5..bc8edef038fc 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_called_with.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_called_with.rs
@@ -5,21 +5,20 @@ use crate::{
 };
 
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
-#[derive(Debug, Error, Diagnostic)]
-enum PreferCalledWithDiagnostic {
-    #[error("eslint-plugin-jest(prefer-called-with): Suggest using `toBeCalledWith()` or `toHaveBeenCalledWith()`.")]
-    #[diagnostic(severity(warning), help("Prefer toBeCalledWith(/* expected args */)"))]
-    UseToBeCalledWith(#[label] Span),
-    #[error("eslint-plugin-jest(prefer-called-with): Suggest using `toBeCalledWith()` or `toHaveBeenCalledWith()`.")]
-    #[diagnostic(severity(warning), help("Prefer toHaveBeenCalledWith(/* expected args */)"))]
-    UseHaveBeenCalledWith(#[label] Span),
+fn use_to_be_called_with(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-called-with): Suggest using `toBeCalledWith()` or `toHaveBeenCalledWith()`.")
+        .with_help("Prefer toBeCalledWith(/* expected args */)")
+        .with_labels([span0.into()])
+}
+
+fn use_have_been_called_with(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-called-with): Suggest using `toBeCalledWith()` or `toHaveBeenCalledWith()`.")
+        .with_help("Prefer toHaveBeenCalledWith(/* expected args */)")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -78,13 +77,9 @@ impl PreferCalledWith {
         if let Some(matcher_property) = jest_fn_call.matcher() {
             if let Some(matcher_name) = matcher_property.name() {
                 if matcher_name == "toBeCalled" {
-                    ctx.diagnostic(PreferCalledWithDiagnostic::UseToBeCalledWith(
-                        matcher_property.span,
-                    ));
+                    ctx.diagnostic(use_to_be_called_with(matcher_property.span));
                 } else if matcher_name == "toHaveBeenCalled" {
-                    ctx.diagnostic(PreferCalledWithDiagnostic::UseHaveBeenCalledWith(
-                        matcher_property.span,
-                    ));
+                    ctx.diagnostic(use_have_been_called_with(matcher_property.span));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/jest/prefer_comparison_matcher.rs b/crates/oxc_linter/src/rules/jest/prefer_comparison_matcher.rs
index 73b66155d196..d8d534d27050 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_comparison_matcher.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_comparison_matcher.rs
@@ -11,20 +11,17 @@ use oxc_ast::{
     ast::{Argument, BinaryExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::BinaryOperator;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jest(prefer-comparison-matcher): Suggest using the built-in comparison matchers"
-)]
-#[diagnostic(severity(warning), help("Prefer using `{0:?}` instead"))]
-struct UseToBeComparison(&'static str, #[label] pub Span);
+fn use_to_be_comparison(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-comparison-matcher): Suggest using the built-in comparison matchers")
+        .with_help(format!("Prefer using `{x0:?}` instead"))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferComparisonMatcher;
@@ -116,7 +113,7 @@ impl PreferComparisonMatcher {
             return;
         };
 
-        ctx.diagnostic_with_fix(UseToBeComparison(prefer_matcher_name, matcher.span), || {
+        ctx.diagnostic_with_fix(use_to_be_comparison(prefer_matcher_name, matcher.span), || {
             // This is to handle the case can be transform into the following case:
             // expect(value > 1,).toEqual(true,) => expect(value,).toBeGreaterThan(1,)
             //                 ^              ^
diff --git a/crates/oxc_linter/src/rules/jest/prefer_equality_matcher.rs b/crates/oxc_linter/src/rules/jest/prefer_equality_matcher.rs
index 972bf8e4abc2..c4b038e0c660 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_equality_matcher.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_equality_matcher.rs
@@ -3,25 +3,21 @@ use crate::{
     rule::Rule,
     utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
 };
+use oxc_diagnostics::OxcDiagnostic;
 
 use oxc_ast::{
     ast::{Argument, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::BinaryOperator;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jest(prefer-equality-matcher): Suggest using the built-in equality matchers."
-)]
-#[diagnostic(severity(warning), help("Prefer using one of the equality matchers instead"))]
-struct UseEqualityMatcherDiagnostic(#[label] Span);
+fn use_equality_matcher_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-equality-matcher): Suggest using the built-in equality matchers.")
+        .with_help("Prefer using one of the equality matchers instead")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferEqualityMatcher;
@@ -92,7 +88,7 @@ impl PreferEqualityMatcher {
             return;
         };
 
-        ctx.diagnostic(UseEqualityMatcherDiagnostic(matcher.span));
+        ctx.diagnostic(use_equality_matcher_diagnostic(matcher.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/jest/prefer_expect_resolves.rs b/crates/oxc_linter/src/rules/jest/prefer_expect_resolves.rs
index 363373f9882a..49d50c52847c 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_expect_resolves.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_expect_resolves.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -19,10 +17,11 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(prefer-expect-resolves): Prefer `await expect(...).resolves` over `expect(await ...)` syntax.")]
-#[diagnostic(severity(warning), help("Use `await expect(...).resolves` instead"))]
-struct ExpectResolves(#[label] pub Span);
+fn expect_resolves(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-expect-resolves): Prefer `await expect(...).resolves` over `expect(await ...)` syntax.")
+        .with_help("Use `await expect(...).resolves` instead")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferExpectResolves;
@@ -108,7 +107,7 @@ impl PreferExpectResolves {
             return;
         };
 
-        ctx.diagnostic_with_fix(ExpectResolves(await_expr.span), || {
+        ctx.diagnostic_with_fix(expect_resolves(await_expr.span), || {
             let content = Self::build_code(&jest_expect_fn_call, call_expr, ident.span, ctx);
             Fix::new(content, call_expr.span)
         });
diff --git a/crates/oxc_linter/src/rules/jest/prefer_lowercase_title.rs b/crates/oxc_linter/src/rules/jest/prefer_lowercase_title.rs
index a06b0e6f5b09..c5f97c0a12cf 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_lowercase_title.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_lowercase_title.rs
@@ -1,10 +1,8 @@
 use oxc_ast::{ast::Argument, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{
     context::LintContext,
@@ -16,10 +14,13 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(prefer-lowercase-title): Enforce lowercase test names")]
-#[diagnostic(severity(warning), help("`{0:?}`s should begin with lowercase"))]
-struct UnexpectedLowercase(CompactStr, #[label] Span);
+fn unexpected_lowercase(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(prefer-lowercase-title): Enforce lowercase test names",
+    )
+    .with_help(format!("`{x0:?}`s should begin with lowercase"))
+    .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferLowercaseTitleConfig {
@@ -216,7 +217,7 @@ impl PreferLowercaseTitle {
             }
 
             ctx.diagnostic_with_fix(
-                UnexpectedLowercase(string_expr.value.to_compact_str(), string_expr.span),
+                unexpected_lowercase(string_expr.value.as_str(), string_expr.span),
                 || {
                     let mut content = ctx.codegen();
                     content.print_str(first_char.to_ascii_lowercase().to_string().as_bytes());
@@ -246,7 +247,7 @@ impl PreferLowercaseTitle {
             }
 
             ctx.diagnostic_with_fix(
-                UnexpectedLowercase(template_string.to_compact_str(), template_expr.span),
+                unexpected_lowercase(template_string.as_str(), template_expr.span),
                 || {
                     let mut content = ctx.codegen();
                     content.print_str(first_char.to_ascii_lowercase().to_string().as_bytes());
diff --git a/crates/oxc_linter/src/rules/jest/prefer_mock_promise_shorthand.rs b/crates/oxc_linter/src/rules/jest/prefer_mock_promise_shorthand.rs
index aae173986957..e4220e134bc0 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_mock_promise_shorthand.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_mock_promise_shorthand.rs
@@ -2,19 +2,16 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{Atom, CompactStr, Span};
+use oxc_span::{Atom, Span};
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, utils::get_node_name};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(prefer-mock-promise-shorthand): Prefer mock resolved/rejected shorthands for promises")]
-#[diagnostic(severity(warning), help("Prefer {0:?}"))]
-struct UseMockShorthand(CompactStr, #[label] Span);
+fn use_mock_shorthand(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-mock-promise-shorthand): Prefer mock resolved/rejected shorthands for promises").with_help(format!("Prefer {x0:?}")).with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferMockPromiseShorthand;
@@ -152,17 +149,14 @@ impl PreferMockPromiseShorthand {
         // if arguments is more than one, just report it instead of fixing it.
         if call_expr.arguments.len() <= 1 {
             ctx.diagnostic_with_fix(
-                UseMockShorthand(Atom::from(prefer_name).to_compact_str(), property_span),
+                use_mock_shorthand(Atom::from(prefer_name).as_str(), property_span),
                 || {
                     let content = Self::fix(prefer_name, call_expr, ctx);
                     Fix::new(content, Span::new(property_span.start, fix_span.end))
                 },
             );
         } else {
-            ctx.diagnostic(UseMockShorthand(
-                Atom::from(prefer_name).to_compact_str(),
-                property_span,
-            ));
+            ctx.diagnostic(use_mock_shorthand(Atom::from(prefer_name).as_str(), property_span));
         }
     }
 
diff --git a/crates/oxc_linter/src/rules/jest/prefer_spy_on.rs b/crates/oxc_linter/src/rules/jest/prefer_spy_on.rs
index d5ca2709dbae..4d115d1fafc1 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_spy_on.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_spy_on.rs
@@ -5,10 +5,8 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNode;
 use oxc_span::Span;
@@ -20,10 +18,11 @@ use crate::{
     utils::{get_node_name, parse_general_jest_fn_call, PossibleJestNode},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(prefer-spy-on): Suggest using `jest.spyOn()`.")]
-#[diagnostic(severity(warning), help("Use jest.spyOn() instead"))]
-struct UseJestSpyOn(#[label] pub Span);
+fn use_jest_spy_on(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-spy-on): Suggest using `jest.spyOn()`.")
+        .with_help("Use jest.spyOn() instead")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferSpyOn;
@@ -111,7 +110,7 @@ impl PreferSpyOn {
         }
 
         ctx.diagnostic_with_fix(
-            UseJestSpyOn(Span::new(call_expr.span.start, first_fn_member.span.end)),
+            use_jest_spy_on(Span::new(call_expr.span.start, first_fn_member.span.end)),
             || {
                 let (end, has_mock_implementation) = if jest_fn_call.members.len() > 1 {
                     let second = &jest_fn_call.members[1];
@@ -234,10 +233,7 @@ fn tests() {
         ("obj['prop' + 1] = jest['fn']()", None),
         ("obj.one.two = jest.fn(); const test = 10;", None),
         ("obj.a = jest.fn(() => 10,)", None),
-        (
-            "obj.a.b = jest.fn(() => ({})).mockReturnValue('default').mockReturnValueOnce('first call'); test();",
-            None,
-        ),
+        ("obj.a.b = jest.fn(() => ({})).mockReturnValue('default').mockReturnValueOnce('first call'); test();", None),
         ("window.fetch = jest.fn(() => ({})).one.two().three().four", None),
         ("foo[bar] = jest.fn().mockReturnValue(undefined)", None),
         (
@@ -250,43 +246,19 @@ fn tests() {
     ];
 
     let fix = vec![
-        (
-            "obj.a = jest.fn(); const test = 10;",
-            "jest.spyOn(obj, 'a').mockImplementation(); const test = 10;",
-            None,
-        ),
+        ("obj.a = jest.fn(); const test = 10;", "jest.spyOn(obj, 'a').mockImplementation(); const test = 10;", None),
         ("Date['now'] = jest['fn']()", "jest.spyOn(Date, 'now').mockImplementation()", None),
-        (
-            "window[`${name}`] = jest[`fn`]()",
-            "jest.spyOn(window, `${name}`).mockImplementation()",
-            None,
-        ),
-        (
-            "obj['prop' + 1] = jest['fn']()",
-            "jest.spyOn(obj, 'prop' + 1).mockImplementation()",
-            None,
-        ),
-        (
-            "obj.one.two = jest.fn(); const test = 10;",
-            "jest.spyOn(obj.one, 'two').mockImplementation(); const test = 10;",
-            None,
-        ),
+        ("window[`${name}`] = jest[`fn`]()", "jest.spyOn(window, `${name}`).mockImplementation()", None),
+        ("obj['prop' + 1] = jest['fn']()", "jest.spyOn(obj, 'prop' + 1).mockImplementation()", None),
+        ("obj.one.two = jest.fn(); const test = 10;", "jest.spyOn(obj.one, 'two').mockImplementation(); const test = 10;", None),
         ("obj.a = jest.fn(() => 10,)", "jest.spyOn(obj, 'a').mockImplementation(() => 10)", None),
         (
             "obj.a.b = jest.fn(() => ({})).mockReturnValue('default').mockReturnValueOnce('first call'); test();",
             "jest.spyOn(obj.a, 'b').mockImplementation(() => ({})).mockReturnValue('default').mockReturnValueOnce('first call'); test();",
             None,
         ),
-        (
-            "window.fetch = jest.fn(() => ({})).one.two().three().four",
-            "jest.spyOn(window, 'fetch').mockImplementation(() => ({})).one.two().three().four",
-            None,
-        ),
-        (
-            "foo[bar] = jest.fn().mockReturnValue(undefined)",
-            "jest.spyOn(foo, bar).mockImplementation().mockReturnValue(undefined)",
-            None,
-        ),
+        ("window.fetch = jest.fn(() => ({})).one.two().three().four", "jest.spyOn(window, 'fetch').mockImplementation(() => ({})).one.two().three().four", None),
+        ("foo[bar] = jest.fn().mockReturnValue(undefined)", "jest.spyOn(foo, bar).mockImplementation().mockReturnValue(undefined)", None),
         (
             "
                 foo.bar = jest.fn().mockImplementation(baz => baz)
diff --git a/crates/oxc_linter/src/rules/jest/prefer_strict_equal.rs b/crates/oxc_linter/src/rules/jest/prefer_strict_equal.rs
index 1f0bc8db2441..2e02c0c23726 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_strict_equal.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_strict_equal.rs
@@ -4,19 +4,19 @@ use crate::{
     rule::Rule,
     utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
 };
+use oxc_diagnostics::OxcDiagnostic;
 
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(prefer-strict-equal): Suggest using `toStrictEqual()`.")]
-#[diagnostic(severity(warning), help("Use `toStrictEqual()` instead"))]
-struct UseToStrictEqual(#[label] Span);
+fn use_to_strict_equal(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(prefer-strict-equal): Suggest using `toStrictEqual()`.",
+    )
+    .with_help("Use `toStrictEqual()` instead")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferStrictEqual;
@@ -67,7 +67,7 @@ impl PreferStrictEqual {
         };
 
         if matcher_name.eq("toEqual") {
-            ctx.diagnostic_with_fix(UseToStrictEqual(matcher.span), || {
+            ctx.diagnostic_with_fix(use_to_strict_equal(matcher.span), || {
                 let mut formatter = ctx.codegen();
                 formatter.print_str(
                     matcher
diff --git a/crates/oxc_linter/src/rules/jest/prefer_to_be.rs b/crates/oxc_linter/src/rules/jest/prefer_to_be.rs
index 61139dbd46f4..89abc142f189 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_to_be.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_to_be.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -19,23 +17,31 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum PreferToBeDiagnostic {
-    #[error("eslint-plugin-jest(prefer-to-be): Use `toBe` when expecting primitive literals.")]
-    #[diagnostic(severity(warning))]
-    UseToBe(#[label] Span),
-    #[error("eslint-plugin-jest(prefer-to-be): Use `toBeUndefined` instead.")]
-    #[diagnostic(severity(warning))]
-    UseToBeUndefined(#[label] Span),
-    #[error("eslint-plugin-jest(prefer-to-be): Use `toBeDefined` instead.")]
-    #[diagnostic(severity(warning))]
-    UseToBeDefined(#[label] Span),
-    #[error("eslint-plugin-jest(prefer-to-be): Use `toBeNull` instead.")]
-    #[diagnostic(severity(warning))]
-    UseToBeNull(#[label] Span),
-    #[error("eslint-plugin-jest(prefer-to-be): Use `toBeNaN` instead.")]
-    #[diagnostic(severity(warning))]
-    UseToBeNaN(#[label] Span),
+fn use_to_be(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(prefer-to-be): Use `toBe` when expecting primitive literals.",
+    )
+    .with_labels([span0.into()])
+}
+
+fn use_to_be_undefined(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-to-be): Use `toBeUndefined` instead.")
+        .with_labels([span0.into()])
+}
+
+fn use_to_be_defined(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-to-be): Use `toBeDefined` instead.")
+        .with_labels([span0.into()])
+}
+
+fn use_to_be_null(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-to-be): Use `toBeNull` instead.")
+        .with_labels([span0.into()])
+}
+
+fn use_to_be_na_n(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-to-be): Use `toBeNaN` instead.")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -224,7 +230,7 @@ impl PreferToBe {
         let maybe_not_modifier = modifiers.iter().find(|modifier| modifier.is_name_equal("not"));
 
         if kind == &PreferToBeKind::Undefined {
-            ctx.diagnostic_with_fix(PreferToBeDiagnostic::UseToBeUndefined(span), || {
+            ctx.diagnostic_with_fix(use_to_be_undefined(span), || {
                 let new_matcher =
                     if is_cmp_mem_expr { "[\"toBeUndefined\"]()" } else { "toBeUndefined()" };
                 if let Some(not_modifier) = maybe_not_modifier {
@@ -234,7 +240,7 @@ impl PreferToBe {
                 }
             });
         } else if kind == &PreferToBeKind::Defined {
-            ctx.diagnostic_with_fix(PreferToBeDiagnostic::UseToBeDefined(span), || {
+            ctx.diagnostic_with_fix(use_to_be_defined(span), || {
                 let (new_matcher, start) = if is_cmp_mem_expr {
                     ("[\"toBeDefined\"]()", modifiers.first().unwrap().span.end)
                 } else {
@@ -244,17 +250,17 @@ impl PreferToBe {
                 Fix::new(new_matcher.to_string(), Span::new(start, end))
             });
         } else if kind == &PreferToBeKind::Null {
-            ctx.diagnostic_with_fix(PreferToBeDiagnostic::UseToBeNull(span), || {
+            ctx.diagnostic_with_fix(use_to_be_null(span), || {
                 let new_matcher = if is_cmp_mem_expr { "\"toBeNull\"]()" } else { "toBeNull()" };
                 Fix::new(new_matcher.to_string(), Span::new(span.start, end))
             });
         } else if kind == &PreferToBeKind::NaN {
-            ctx.diagnostic_with_fix(PreferToBeDiagnostic::UseToBeNaN(span), || {
+            ctx.diagnostic_with_fix(use_to_be_na_n(span), || {
                 let new_matcher = if is_cmp_mem_expr { "\"toBeNaN\"]()" } else { "toBeNaN()" };
                 Fix::new(new_matcher.to_string(), Span::new(span.start, end))
             });
         } else {
-            ctx.diagnostic_with_fix(PreferToBeDiagnostic::UseToBe(span), || {
+            ctx.diagnostic_with_fix(use_to_be(span), || {
                 let new_matcher = if is_cmp_mem_expr { "\"toBe\"" } else { "toBe" };
                 Fix::new(new_matcher.to_string(), span)
             });
diff --git a/crates/oxc_linter/src/rules/jest/prefer_to_contain.rs b/crates/oxc_linter/src/rules/jest/prefer_to_contain.rs
index e35e799dcba5..a9ce8690bcd2 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_to_contain.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_to_contain.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -18,10 +16,10 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(prefer-to-contain): Suggest using `toContain()`.")]
-#[diagnostic(severity(warning))]
-struct UseToContain(#[label] pub Span);
+fn use_to_contain(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-to-contain): Suggest using `toContain()`.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferToContain;
@@ -122,7 +120,7 @@ impl PreferToContain {
             return;
         }
 
-        ctx.diagnostic(UseToContain(matcher.span));
+        ctx.diagnostic(use_to_contain(matcher.span));
     }
 
     fn is_fixable_includes_call_expression(call_expr: &CallExpression) -> bool {
@@ -171,10 +169,7 @@ fn tests() {
         ("expect(a.includes(b)).toBe(...true)", None),
         ("expect(a);", None),
         // typescript
-        (
-            "(expect('Model must be bound to an array if the multiple property is true') as any).toHaveBeenTipped()",
-            None,
-        ),
+        ("(expect('Model must be bound to an array if the multiple property is true') as any).toHaveBeenTipped()", None),
         ("expect(a.includes(b)).toEqual(0 as boolean);", None),
     ];
 
diff --git a/crates/oxc_linter/src/rules/jest/prefer_to_have_length.rs b/crates/oxc_linter/src/rules/jest/prefer_to_have_length.rs
index e5b3c5cbfa88..d83c2e33902c 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_to_have_length.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_to_have_length.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{match_member_expression, CallExpression, Expression, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -19,10 +17,12 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(prefer-to-have-length): Suggest using `toHaveLength()`.")]
-#[diagnostic(severity(warning))]
-struct UseToHaveLength(#[label] pub Span);
+fn use_to_have_length(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(prefer-to-have-length): Suggest using `toHaveLength()`.",
+    )
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferToHaveLength;
@@ -146,7 +146,7 @@ impl PreferToHaveLength {
             return;
         }
 
-        ctx.diagnostic_with_fix(UseToHaveLength(matcher.span), || {
+        ctx.diagnostic_with_fix(use_to_have_length(matcher.span), || {
             let code = Self::build_code(static_mem_expr, kind, property_name, ctx);
             let end = if call_expr.arguments.len() > 0 {
                 call_expr.arguments.first().unwrap().span().start
diff --git a/crates/oxc_linter/src/rules/jest/prefer_todo.rs b/crates/oxc_linter/src/rules/jest/prefer_todo.rs
index 9dda938ce62a..74b46fd0d5c8 100644
--- a/crates/oxc_linter/src/rules/jest/prefer_todo.rs
+++ b/crates/oxc_linter/src/rules/jest/prefer_todo.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -19,15 +17,15 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(prefer-todo): Suggest using `test.todo`.")]
-#[diagnostic(severity(warning))]
-struct EmptyTest(#[label] pub Span);
+fn empty_test(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-todo): Suggest using `test.todo`.")
+        .with_labels([span0.into()])
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(prefer-todo): Suggest using `test.todo`.")]
-#[diagnostic(severity(warning))]
-struct UnImplementedTestDiagnostic(#[label] pub Span);
+fn un_implemented_test_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jest(prefer-todo): Suggest using `test.todo`.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferTodo;
@@ -82,11 +80,13 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
 
         if counts == 1 && !filter_todo_case(call_expr) {
             let (content, span) = get_fix_content(call_expr);
-            ctx.diagnostic_with_fix(UnImplementedTestDiagnostic(span), || Fix::new(content, span));
+            ctx.diagnostic_with_fix(un_implemented_test_diagnostic(span), || {
+                Fix::new(content, span)
+            });
         }
 
         if counts > 1 && is_empty_function(call_expr) {
-            ctx.diagnostic_with_fix(EmptyTest(call_expr.span), || {
+            ctx.diagnostic_with_fix(empty_test(call_expr.span), || {
                 let (content, span) = build_code(call_expr, ctx);
                 Fix::new(content, span)
             });
diff --git a/crates/oxc_linter/src/rules/jest/require_hook.rs b/crates/oxc_linter/src/rules/jest/require_hook.rs
index 54d01690012c..135b07f862f5 100644
--- a/crates/oxc_linter/src/rules/jest/require_hook.rs
+++ b/crates/oxc_linter/src/rules/jest/require_hook.rs
@@ -3,10 +3,8 @@ use oxc_ast::{
     ast::{Argument, Expression, Statement, VariableDeclarationKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNode;
 use oxc_span::Span;
@@ -20,10 +18,13 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(require-hook): Require setup and teardown code to be within a hook.")]
-#[diagnostic(severity(warning), help("This should be done within a hook"))]
-struct UseHook(#[label] pub Span);
+fn use_hook(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jest(require-hook): Require setup and teardown code to be within a hook.",
+    )
+    .with_help("This should be done within a hook")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct RequireHookConfig {
@@ -220,7 +221,7 @@ impl RequireHook {
                     !init_call.is_null_or_undefined()
                 })
             {
-                ctx.diagnostic(UseHook(var_decl.span));
+                ctx.diagnostic(use_hook(var_decl.span));
             }
         }
     }
@@ -239,7 +240,7 @@ impl RequireHook {
                 || name.starts_with("jest.")
                 || self.allowed_function_calls.contains(&name))
             {
-                ctx.diagnostic(UseHook(call_expr.span));
+                ctx.diagnostic(use_hook(call_expr.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jest/require_to_throw_message.rs b/crates/oxc_linter/src/rules/jest/require_to_throw_message.rs
index 96d183ecdcef..f8be3c1ddabe 100644
--- a/crates/oxc_linter/src/rules/jest/require_to_throw_message.rs
+++ b/crates/oxc_linter/src/rules/jest/require_to_throw_message.rs
@@ -1,8 +1,6 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -12,10 +10,13 @@ use crate::{
     utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(require-to-throw-message): Require a message for {0:?}.")]
-#[diagnostic(severity(warning), help("Add an error message to {0:?}"))]
-struct RequireToThrowMessageDiagnostic(pub String, #[label] pub Span);
+fn require_to_throw_message_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-jest(require-to-throw-message): Require a message for {x0:?}."
+    ))
+    .with_help(format!("Add an error message to {x0:?}"))
+    .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct RequireToThrowMessage;
@@ -81,7 +82,7 @@ impl RequireToThrowMessage {
             && (matcher_name == "toThrow" || matcher_name == "toThrowError")
             && !has_not
         {
-            ctx.diagnostic(RequireToThrowMessageDiagnostic(matcher_name.to_string(), matcher.span));
+            ctx.diagnostic(require_to_throw_message_diagnostic(&matcher_name, matcher.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/jest/valid_describe_callback.rs b/crates/oxc_linter/src/rules/jest/valid_describe_callback.rs
index b5a43e68cb27..044e366589b0 100644
--- a/crates/oxc_linter/src/rules/jest/valid_describe_callback.rs
+++ b/crates/oxc_linter/src/rules/jest/valid_describe_callback.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Argument, Expression, FunctionBody, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -18,10 +16,11 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(valid-describe-callback): {0:?}")]
-#[diagnostic(severity(warning), help("{1:?}"))]
-struct ValidDescribeCallbackDiagnostic(&'static str, &'static str, #[label] pub Span);
+fn valid_describe_callback_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jest(valid-describe-callback): {x0:?}"))
+        .with_help(format!("{x1:?}"))
+        .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ValidDescribeCallback;
@@ -74,7 +73,9 @@ impl Rule for ValidDescribeCallback {
 
 fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>) {
     let node = possible_jest_node.node;
-    let AstKind::CallExpression(call_expr) = node.kind() else { return };
+    let AstKind::CallExpression(call_expr) = node.kind() else {
+        return;
+    };
     let Some(jest_fn_call) = parse_general_jest_fn_call(call_expr, possible_jest_node, ctx) else {
         return;
     };
@@ -151,7 +152,7 @@ fn find_first_return_stmt_span(function_body: &FunctionBody) -> Option<Span> {
 
 fn diagnostic(ctx: &LintContext, span: Span, message: Message) {
     let (error, help) = message.details();
-    ctx.diagnostic(ValidDescribeCallbackDiagnostic(error, help, span));
+    ctx.diagnostic(valid_describe_callback_diagnostic(error, help, span));
 }
 
 #[derive(Clone, Copy)]
diff --git a/crates/oxc_linter/src/rules/jest/valid_expect.rs b/crates/oxc_linter/src/rules/jest/valid_expect.rs
index 1ec09d8da2a8..7676f92f5af1 100644
--- a/crates/oxc_linter/src/rules/jest/valid_expect.rs
+++ b/crates/oxc_linter/src/rules/jest/valid_expect.rs
@@ -2,12 +2,10 @@ use oxc_ast::{
     ast::{Expression, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, GetSpan, Span};
+use oxc_span::{GetSpan, Span};
 
 use crate::{
     context::LintContext,
@@ -18,10 +16,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(valid-expect): {0:?}")]
-#[diagnostic(severity(warning), help("{1:?}"))]
-struct ValidExpectDiagnostic(CompactStr, &'static str, #[label] Span);
+fn valid_expect_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jest(valid-expect): {x0:?}"))
+        .with_help(format!("{x1:?}"))
+        .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ValidExpect(Box<ValidExpectConfig>);
@@ -111,7 +110,9 @@ impl Rule for ValidExpect {
 impl ValidExpect {
     fn run<'a>(&self, possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>) {
         let node = possible_jest_node.node;
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
         let Some(jest_fn_call) = parse_expect_jest_fn_call(call_expr, possible_jest_node, ctx)
         else {
             return;
@@ -123,42 +124,44 @@ impl ValidExpect {
         match jest_fn_call.expect_error {
             Some(ExpectError::MatcherNotFound) => {
                 let (error, help) = Message::MatcherNotFound.details();
-                ctx.diagnostic(ValidExpectDiagnostic(error, help, reporting_span));
+                ctx.diagnostic(valid_expect_diagnostic(error, help, reporting_span));
                 return;
             }
             Some(ExpectError::MatcherNotCalled) => {
                 let (error, help) = Message::MatcherNotCalled.details();
-                ctx.diagnostic(ValidExpectDiagnostic(error, help, reporting_span));
+                ctx.diagnostic(valid_expect_diagnostic(error, help, reporting_span));
                 return;
             }
             Some(ExpectError::ModifierUnknown) => {
                 let (error, help) = Message::ModifierUnknown.details();
-                ctx.diagnostic(ValidExpectDiagnostic(error, help, reporting_span));
+                ctx.diagnostic(valid_expect_diagnostic(error, help, reporting_span));
                 return;
             }
             None => {}
         }
 
-        let Some(Expression::CallExpression(call_expr)) = jest_fn_call.head.parent else { return };
+        let Some(Expression::CallExpression(call_expr)) = jest_fn_call.head.parent else {
+            return;
+        };
 
         if call_expr.arguments.len() < self.min_args {
-            let error = CompactStr::from(format!(
+            let error = format!(
                 "Expect takes at most {} argument{} ",
                 self.min_args,
                 if self.min_args > 1 { "s" } else { "" }
-            ));
+            );
             let help = "Remove the extra arguments.";
-            ctx.diagnostic(ValidExpectDiagnostic(error, help, call_expr.span));
+            ctx.diagnostic(valid_expect_diagnostic(&error, help, call_expr.span));
             return;
         }
         if call_expr.arguments.len() > self.max_args {
-            let error = CompactStr::from(format!(
+            let error = format!(
                 "Expect requires at least {} argument{} ",
                 self.max_args,
                 if self.max_args > 1 { "s" } else { "" }
-            ));
+            );
             let help = "Add the missing arguments.";
-            ctx.diagnostic(ValidExpectDiagnostic(error, help, call_expr.span));
+            ctx.diagnostic(valid_expect_diagnostic(&error, help, call_expr.span));
             return;
         }
 
@@ -188,19 +191,25 @@ impl ValidExpect {
         let Some(final_node) = find_promise_call_expression_node(node, ctx, target_node) else {
             return;
         };
-        let Some(parent) = ctx.nodes().parent_node(final_node.id()) else { return };
+        let Some(parent) = ctx.nodes().parent_node(final_node.id()) else {
+            return;
+        };
         if !is_acceptable_return_node(parent, !self.always_await, ctx) {
             let span;
             let (error, help) = if target_node.id() == final_node.id() {
-                let AstKind::CallExpression(call_expr) = target_node.kind() else { return };
+                let AstKind::CallExpression(call_expr) = target_node.kind() else {
+                    return;
+                };
                 span = call_expr.span;
                 Message::AsyncMustBeAwaited.details()
             } else {
-                let AstKind::CallExpression(call_expr) = final_node.kind() else { return };
+                let AstKind::CallExpression(call_expr) = final_node.kind() else {
+                    return;
+                };
                 span = call_expr.span;
                 Message::PromisesWithAsyncAssertionsMustBeAwaited.details()
             };
-            ctx.diagnostic(ValidExpectDiagnostic(error, help, span));
+            ctx.diagnostic(valid_expect_diagnostic(error, help, span));
         }
     }
 }
@@ -246,7 +255,9 @@ fn is_acceptable_return_node<'a, 'b>(
             | AstKind::Argument(_)
             | AstKind::ExpressionStatement(_)
             | AstKind::FunctionBody(_) => {
-                let Some(parent) = ctx.nodes().parent_node(node.id()) else { return false };
+                let Some(parent) = ctx.nodes().parent_node(node.id()) else {
+                    return false;
+                };
                 node = parent;
             }
             AstKind::ArrowFunctionExpression(arrow_expr) => return arrow_expr.expression,
@@ -338,10 +349,18 @@ fn get_parent_if_thenable<'a, 'b>(
     let grandparent =
         ctx.nodes().parent_node(node.id()).and_then(|node| ctx.nodes().parent_node(node.id()));
 
-    let Some(grandparent) = grandparent else { return node };
-    let AstKind::CallExpression(call_expr) = grandparent.kind() else { return node };
-    let Some(member_expr) = call_expr.callee.as_member_expression() else { return node };
-    let Some(name) = member_expr.static_property_name() else { return node };
+    let Some(grandparent) = grandparent else {
+        return node;
+    };
+    let AstKind::CallExpression(call_expr) = grandparent.kind() else {
+        return node;
+    };
+    let Some(member_expr) = call_expr.callee.as_member_expression() else {
+        return node;
+    };
+    let Some(name) = member_expr.static_property_name() else {
+        return node;
+    };
 
     if ["then", "catch"].contains(&name) {
         return get_parent_if_thenable(grandparent, ctx);
@@ -360,25 +379,24 @@ enum Message {
 }
 
 impl Message {
-    fn details(self) -> (CompactStr, &'static str) {
+    fn details(self) -> (&'static str, &'static str) {
         match self {
             Self::MatcherNotFound => (
-                CompactStr::from("Expect must have a corresponding matcher call."),
+                "Expect must have a corresponding matcher call.",
                 "Did you forget add a matcher(e.g. `toBe`, `toBeDefined`)",
             ),
             Self::MatcherNotCalled => (
-                CompactStr::from("Matchers must be called to assert."),
+                "Matchers must be called to assert.",
                 "You need call your matcher, e.g. `expect(true).toBe(true)`.",
             ),
             Self::ModifierUnknown => {
-                (CompactStr::from("Expect has an unknown modifier."), "Is it a spelling mistake?")
+                ("Expect has an unknown modifier.", "Is it a spelling mistake?")
+            }
+            Self::AsyncMustBeAwaited => {
+                ("Async assertions must be awaited.", "Add `await` to your assertion.")
             }
-            Self::AsyncMustBeAwaited => (
-                CompactStr::from("Async assertions must be awaited."),
-                "Add `await` to your assertion.",
-            ),
             Self::PromisesWithAsyncAssertionsMustBeAwaited => (
-                CompactStr::from("Promises which return async assertions must be awaited."),
+                "Promises which return async assertions must be awaited.",
                 "Add `await` to your assertion.",
             ),
         }
@@ -389,9 +407,7 @@ impl Message {
 fn test_1() {
     use crate::tester::Tester;
 
-    let pass = vec![
-        ("test('valid-expect', async () => { await Promise.race([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); })", None)
-    ];
+    let pass = vec![("test('valid-expect', async () => { await Promise.race([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); })", None)];
     let fail = vec![];
 
     Tester::new(ValidExpect::NAME, pass, fail).with_jest_plugin(true).test();
@@ -432,14 +448,26 @@ fn test() {
         ("test('valid-expect', async () => { await Promise.allSettled([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); });", None),
         ("test('valid-expect', async () => { await Promise.any([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); });", None),
         ("test('valid-expect', async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log('valid-case')); });", None),
-        ("test('valid-expect', async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log('valid-case')).then(() => console.log('another valid case')); });", None),
+        (
+            "test('valid-expect', async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log('valid-case')).then(() => console.log('another valid case')); });",
+            None,
+        ),
         ("test('valid-expect', async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().catch(() => console.log('valid-case')); });", None),
-        ("test('valid-expect', async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log('valid-case')).catch(() => console.log('another valid case')); });", None),
+        (
+            "test('valid-expect', async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log('valid-case')).catch(() => console.log('another valid case')); });",
+            None,
+        ),
         ("test('valid-expect', async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => { expect(someMock).toHaveBeenCalledTimes(1); }); });", None),
         ("test('valid-expect', async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log('valid-case')); });", None),
-        ("test('valid-expect', async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log('valid-case')).then(() => console.log('another valid case')); });", None),
+        (
+            "test('valid-expect', async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log('valid-case')).then(() => console.log('another valid case')); });",
+            None,
+        ),
         ("test('valid-expect', async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().catch(() => console.log('valid-case')); });", None),
-        ("test('valid-expect', async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log('valid-case')).catch(() => console.log('another valid case')); });", None),
+        (
+            "test('valid-expect', async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log('valid-case')).catch(() => console.log('another valid case')); });",
+            None,
+        ),
         ("test('valid-expect', async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => { expect(someMock).toHaveBeenCalledTimes(1); }); });", None),
         (
             "
@@ -449,7 +477,7 @@ fn test() {
                     });
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -459,7 +487,7 @@ fn test() {
                     });
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -467,7 +495,7 @@ fn test() {
                     return expect(functionReturningAPromise()).resolves.toEqual(1).then(() => expect(Promise.resolve(2)).resolves.toBe(1));
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -479,7 +507,7 @@ fn test() {
                     }
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -491,7 +519,7 @@ fn test() {
                     }
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -505,7 +533,7 @@ fn test() {
                     }
                 });
             ",
-            None
+            None,
         ),
         ("expect(1).toBe(2);", Some(serde_json::json!([{ "maxArgs": 2 }]))),
         ("expect(1, '1 !== 2').toBe(2);", Some(serde_json::json!([{ "maxArgs": 2 }]))),
@@ -513,7 +541,7 @@ fn test() {
         ("test('valid-expect', () => { expect(2).not.toBe(2); });", Some(serde_json::json!([{ "asyncMatchers": ["toRejectWith"] }]))),
         ("test('valid-expect', () => { expect(Promise.reject(2)).toRejectWith(2); });", Some(serde_json::json!([{ "asyncMatchers": ["toResolveWith"] }]))),
         ("test('valid-expect', async () => { await expect(Promise.resolve(2)).toResolve(); });", Some(serde_json::json!([{ "asyncMatchers": ["toResolveWith"] }]))),
-        ("test('valid-expect', async () => { expect(Promise.resolve(2)).toResolve(); });", Some(serde_json::json!([{ "asyncMatchers": ["toResolveWith"] }])))
+        ("test('valid-expect', async () => { expect(Promise.resolve(2)).toResolve(); });", Some(serde_json::json!([{ "asyncMatchers": ["toResolveWith"] }]))),
     ];
 
     let fail = vec![
@@ -551,7 +579,7 @@ fn test() {
                     }
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -563,7 +591,7 @@ fn test() {
                     }
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -577,7 +605,7 @@ fn test() {
                     }
                 });
             ",
-            None
+            None,
         ),
         ("test('valid-expect', () => { expect(Promise.resolve(2)).resolves.toBeDefined(); });", None),
         ("test('valid-expect', () => { expect(Promise.resolve(2)).toResolve(); });", None),
@@ -598,7 +626,7 @@ fn test() {
                 expect(Promise.resolve(1)).rejects.toBeDefined();
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -607,7 +635,7 @@ fn test() {
                     expect(Promise.resolve(1)).rejects.toBeDefined();
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -616,7 +644,7 @@ fn test() {
                     return expect(Promise.resolve(1)).rejects.toBeDefined();
                 });
             ",
-            Some(serde_json::json!([{ "alwaysAwait": true }]))
+            Some(serde_json::json!([{ "alwaysAwait": true }])),
         ),
         (
             "
@@ -625,7 +653,7 @@ fn test() {
                     return expect(Promise.resolve(1)).rejects.toBeDefined();
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -634,7 +662,7 @@ fn test() {
                     return expect(Promise.resolve(1)).rejects.toBeDefined();
                 });
             ",
-            Some(serde_json::json!([{ "alwaysAwait": true }]))
+            Some(serde_json::json!([{ "alwaysAwait": true }])),
         ),
         (
             "
@@ -643,7 +671,7 @@ fn test() {
                     return expect(Promise.resolve(1)).toReject();
                 });
             ",
-            Some(serde_json::json!([{ "alwaysAwait": true }]))
+            Some(serde_json::json!([{ "alwaysAwait": true }])),
         ),
         (
             "
@@ -651,7 +679,7 @@ fn test() {
                     Promise.resolve(expect(Promise.resolve(2)).resolves.not.toBeDefined());
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -659,7 +687,7 @@ fn test() {
                     Promise.reject(expect(Promise.resolve(2)).resolves.not.toBeDefined());
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -667,7 +695,7 @@ fn test() {
                     Promise.x(expect(Promise.resolve(2)).resolves.not.toBeDefined());
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -675,7 +703,7 @@ fn test() {
                     Promise.resolve(expect(Promise.resolve(2)).resolves.not.toBeDefined());
                 });
             ",
-            Some(serde_json::json!([{ "alwaysAwait": true }]))
+            Some(serde_json::json!([{ "alwaysAwait": true }])),
         ),
         (
             "
@@ -686,7 +714,7 @@ fn test() {
                 ]);
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -697,7 +725,7 @@ fn test() {
                 ]);
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -708,7 +736,7 @@ fn test() {
                 ]
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -719,7 +747,7 @@ fn test() {
                 ]
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -730,7 +758,7 @@ fn test() {
                 ]
                 });
             ",
-            None
+            None,
         ),
         ("expect(Promise.resolve(2)).resolves.toBe;", None),
         (
@@ -741,7 +769,7 @@ fn test() {
                     });
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -752,7 +780,7 @@ fn test() {
                     });
                 });
             ",
-            None
+            None,
         ),
         (
             "
@@ -760,8 +788,8 @@ fn test() {
                     await expect(Promise.resolve(1));
                 });
             ",
-            None
-        )
+            None,
+        ),
     ];
 
     Tester::new(ValidExpect::NAME, pass, fail).with_jest_plugin(true).test_and_snapshot();
diff --git a/crates/oxc_linter/src/rules/jest/valid_title.rs b/crates/oxc_linter/src/rules/jest/valid_title.rs
index bcfce5f9cb7d..0b92851f5f81 100644
--- a/crates/oxc_linter/src/rules/jest/valid_title.rs
+++ b/crates/oxc_linter/src/rules/jest/valid_title.rs
@@ -1,15 +1,13 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use std::{collections::HashMap, hash::Hash};
 
 use oxc_ast::{
     ast::{Argument, BinaryExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, GetSpan, Span};
+use oxc_span::{GetSpan, Span};
 use regex::Regex;
 
 use crate::{
@@ -21,10 +19,11 @@ use crate::{
     },
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jest(valid-title): {0:?}")]
-#[diagnostic(severity(warning), help("{1:?}"))]
-struct ValidTitleDiagnostic(CompactStr, &'static str, #[label] pub Span);
+fn valid_title_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jest(valid-title): {x0:?}"))
+        .with_help(format!("{x1:?}"))
+        .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ValidTitle(Box<ValidTitleConfig>);
@@ -292,8 +291,8 @@ fn validate_title(
 
         if let Some(matched) = disallowed_words_reg.find(title) {
             let error = format!("{} is not allowed in test title", matched.as_str());
-            ctx.diagnostic(ValidTitleDiagnostic(
-                CompactStr::from(error),
+            ctx.diagnostic(valid_title_diagnostic(
+                &error,
                 "It is included in the `disallowedWords` of your config file, try to remove it from your title",
                 span,
             ));
@@ -325,11 +324,11 @@ fn validate_title(
         if !regex.is_match(title) {
             let raw_pattern = regex.as_str();
             let message = message.as_ref().map_or_else(
-                || CompactStr::from(format!("{un_prefixed_name} should match {raw_pattern}")),
-                |message| CompactStr::from(message.as_str()),
+                || format!("{un_prefixed_name} should match {raw_pattern}"),
+                std::clone::Clone::clone,
             );
-            ctx.diagnostic(ValidTitleDiagnostic(
-                message,
+            ctx.diagnostic(valid_title_diagnostic(
+                &message,
                 "Make sure the title matches the `mustMatch` of your config file",
                 span,
             ));
@@ -340,12 +339,12 @@ fn validate_title(
         if regex.is_match(title) {
             let raw_pattern = regex.as_str();
             let message = message.as_ref().map_or_else(
-                || CompactStr::from(format!("{un_prefixed_name} should not match {raw_pattern}")),
-                |message| CompactStr::from(message.as_str()),
+                || format!("{un_prefixed_name} should not match {raw_pattern}"),
+                std::string::ToString::to_string,
             );
 
-            ctx.diagnostic(ValidTitleDiagnostic(
-                message,
+            ctx.diagnostic(valid_title_diagnostic(
+                &message,
                 "Make sure the title not matches the `mustNotMatch` of your config file",
                 span,
             ));
@@ -382,7 +381,7 @@ impl Message {
     }
     fn diagnostic(&self, ctx: &LintContext, span: Span) {
         let (error, help) = self.detail();
-        ctx.diagnostic(ValidTitleDiagnostic(CompactStr::from(error), help, span));
+        ctx.diagnostic(valid_title_diagnostic(error, help, span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/jsdoc/check_access.rs b/crates/oxc_linter/src/rules/jsdoc/check_access.rs
index d87def7857ee..2499cb0adb0a 100644
--- a/crates/oxc_linter/src/rules/jsdoc/check_access.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/check_access.rs
@@ -1,7 +1,4 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::phf_set;
@@ -9,21 +6,18 @@ use rustc_hash::FxHashSet;
 
 use crate::{context::LintContext, rule::Rule, utils::should_ignore_as_internal};
 
-#[derive(Debug, Error, Diagnostic)]
-enum CheckAccessDiagnostic {
-    #[error("eslint-plugin-jsdoc(check-access): Invalid access level is specified or missing.")]
-    #[diagnostic(
-        severity(warning),
-        help("Valid access levels are `package`, `private`, `protected`, and `public`.")
-    )]
-    InvalidAccessLevel(#[label] Span),
+fn invalid_access_level(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsdoc(check-access): Invalid access level is specified or missing.",
+    )
+    .with_help("Valid access levels are `package`, `private`, `protected`, and `public`.")
+    .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-jsdoc(check-access): Mixing of @access with @public, @private, @protected, or @package on the same doc block.")]
-    #[diagnostic(
-        severity(warning),
-        help("There should be only one instance of access tag in a JSDoc comment.")
-    )]
-    RedundantAccessTags(#[label] Span),
+fn redundant_access_tags(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsdoc(check-access): Mixing of @access with @public, @private, @protected, or @package on the same doc block.")
+        .with_help("There should be only one instance of access tag in a JSDoc comment.")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -94,14 +88,12 @@ impl Rule for CheckAccess {
                 if tag_name == resolved_access_tag_name
                     && !ACCESS_LEVELS.contains(&comment.parsed())
                 {
-                    ctx.diagnostic(CheckAccessDiagnostic::InvalidAccessLevel(
-                        comment.span_trimmed_first_line(),
-                    ));
+                    ctx.diagnostic(invalid_access_level(comment.span_trimmed_first_line()));
                 }
 
                 // Has redundant access level?
                 if 1 < access_related_tags_count {
-                    ctx.diagnostic(CheckAccessDiagnostic::RedundantAccessTags(tag.kind.span));
+                    ctx.diagnostic(redundant_access_tags(tag.kind.span));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/jsdoc/check_property_names.rs b/crates/oxc_linter/src/rules/jsdoc/check_property_names.rs
index f8737417db9b..dbc61a9503fe 100644
--- a/crates/oxc_linter/src/rules/jsdoc/check_property_names.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/check_property_names.rs
@@ -1,8 +1,4 @@
-use miette::{miette, LabeledSpan};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic, Severity},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -13,14 +9,12 @@ use crate::{
     utils::{should_ignore_as_internal, should_ignore_as_private},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum CheckPropertyNamesDiagnostic {
-    #[error("eslint-plugin-jsdoc(check-property-names): No root defined for @property path.")]
-    #[diagnostic(
-        severity(warning),
-        help("@property path declaration `{1}` appears before any real property.")
-    )]
-    NoRoot(#[label] Span, String),
+fn no_root(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsdoc(check-property-names): No root defined for @property path.",
+    )
+    .with_help(format!("@property path declaration `{x1}` appears before any real property."))
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -95,10 +89,7 @@ impl Rule for CheckPropertyNames {
                     let parent_name = parent_name.trim_end_matches("[]");
 
                     if !seen.contains_key(&parent_name) {
-                        ctx.diagnostic(CheckPropertyNamesDiagnostic::NoRoot(
-                            name_part.span,
-                            type_name.to_string(),
-                        ));
+                        ctx.diagnostic(no_root(name_part.span, type_name));
                     }
                 }
 
@@ -107,18 +98,22 @@ impl Rule for CheckPropertyNames {
             }
 
             for (type_name, spans) in seen.iter().filter(|(_, spans)| 1 < spans.len()) {
-                ctx.diagnostic(miette!(
-                    severity = Severity::Warning,
-                    labels = spans
-                        .iter()
-                        .map(|span| LabeledSpan::at(
+                let labels = spans
+                    .iter()
+                    .map(|span| {
+                        LabeledSpan::at(
                             (span.start as usize)..(span.end as usize),
                             "Duplicated property".to_string(),
-                        ))
-                        .collect::<Vec<_>>(),
-                    help = format!("@property `{type_name}` is duplicated on the same block."),
-                    "eslint-plugin-jsdoc(check-property-names): Duplicate @property found."
-                ));
+                        )
+                    })
+                    .collect::<Vec<_>>();
+                ctx.diagnostic(
+                    OxcDiagnostic::warning(
+                        "eslint-plugin-jsdoc(check-property-names): Duplicate @property found.",
+                    )
+                    .with_help(format!("@property `{type_name}` is duplicated on the same block."))
+                    .with_labels(labels),
+                );
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsdoc/check_tag_names.rs b/crates/oxc_linter/src/rules/jsdoc/check_tag_names.rs
index 6f31fbf313aa..96cb87005d3d 100644
--- a/crates/oxc_linter/src/rules/jsdoc/check_tag_names.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/check_tag_names.rs
@@ -1,7 +1,5 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::phf_set;
@@ -13,10 +11,11 @@ use crate::{
     utils::{should_ignore_as_internal, should_ignore_as_private},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsdoc(check-tag-names): Invalid tag name found.")]
-#[diagnostic(severity(warning), help("{1}"))]
-struct CheckTagNamesDiagnostic(#[label] pub Span, String);
+fn check_tag_names_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsdoc(check-tag-names): Invalid tag name found.")
+        .with_help(x1.to_string())
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct CheckTagNames(Box<CheckTagnamesConfig>);
@@ -235,39 +234,33 @@ impl Rule for CheckTagNames {
 
                 // If user explicitly blocked, report
                 if let Some(reason) = settings.check_blocked_tag_name(tag_name) {
-                    ctx.diagnostic(CheckTagNamesDiagnostic(tag.kind.span, reason));
+                    ctx.diagnostic(check_tag_names_diagnostic(tag.kind.span, &reason));
                     continue;
                 }
 
                 // If preferred or default aliased, report to use it
                 if let Some(reason) = settings.check_preferred_tag_name(tag_name) {
-                    ctx.diagnostic(CheckTagNamesDiagnostic(tag.kind.span, reason));
+                    ctx.diagnostic(check_tag_names_diagnostic(tag.kind.span, &reason));
                     continue;
                 }
 
                 // Additional check for `typed` mode
                 if config.typed {
                     if ALWAYS_INVALID_TAGS_IF_TYPED.contains(tag_name) {
-                        ctx.diagnostic(CheckTagNamesDiagnostic(
+                        ctx.diagnostic(check_tag_names_diagnostic(
                             tag.kind.span,
-                            format!("`@{tag_name}` is redundant when using a type system."),
+                            &format!("`@{tag_name}` is redundant when using a type system."),
                         ));
                         continue;
                     }
 
                     if tag.kind.parsed() == "template" && tag.comment().parsed().is_empty() {
-                        ctx.diagnostic(CheckTagNamesDiagnostic(
-                                tag.kind.span,
-                                format!("`@{tag_name}` without a name is redundant when using a type system."),
-                            ));
+                        ctx.diagnostic(check_tag_names_diagnostic(tag.kind.span, &format!("`@{tag_name}` without a name is redundant when using a type system.")));
                         continue;
                     }
 
                     if !is_ambient && OUTSIDE_AMBIENT_INVALID_TAGS_IF_TYPED.contains(tag_name) {
-                        ctx.diagnostic(CheckTagNamesDiagnostic(
-                                tag.kind.span,
-                                format!("`@{tag_name}` is redundant outside of ambient(`declare` or `.d.ts`) contexts when using a type system."),
-                            ));
+                        ctx.diagnostic(check_tag_names_diagnostic(tag.kind.span, &format!("`@{tag_name}` is redundant outside of ambient(`declare` or `.d.ts`) contexts when using a type system.")));
                         continue;
                     }
                 }
@@ -276,9 +269,9 @@ impl Rule for CheckTagNames {
                 let is_valid = (config.jsx_tags && JSX_TAGS.contains(tag_name))
                     || VALID_BLOCK_TAGS.contains(tag_name);
                 if !is_valid {
-                    ctx.diagnostic(CheckTagNamesDiagnostic(
+                    ctx.diagnostic(check_tag_names_diagnostic(
                         tag.kind.span,
-                        format!("`@{tag_name}` is invalid tag name."),
+                        &format!("`@{tag_name}` is invalid tag name."),
                     ));
                     continue;
                 }
@@ -292,124 +285,165 @@ fn test() {
     use crate::tester::Tester;
 
     let pass = vec![
-("
+        (
+            "
 			          /**
 			           * @param foo (pass: valid name)
 			           */
 			          function quux (foo) {
-			
+
 			          }
-			      ", None, None),
-("
+			      ",
+            None,
+            None,
+        ),
+        (
+            "
 			          /**
 			           * @memberof! foo (pass: valid name)
 			           */
 			          function quux (foo) {
-			
+
 			          }
-			      ", None, None),
-("
+			      ",
+            None,
+            None,
+        ),
+        (
+            "
 			          /**
 			           * @bar foo (pass: invalid name but defined)
 			           */
 			          function quux (foo) {
-			
+
 			          }
-			      ", Some(serde_json::json!([
-        {
-          "definedTags": [
-            "bar",
-          ],
-        },
-      ])), None),
-("
+			      ",
+            Some(serde_json::json!([
+              {
+                "definedTags": [
+                  "bar",
+                ],
+              },
+            ])),
+            None,
+        ),
+        (
+            "
 			          /**
 			           * @baz @bar foo (pass: invalid names but defined)
 			           */
 			          function quux (foo) {
-			
+
 			          }
-			      ", Some(serde_json::json!([
-        {
-          "definedTags": [
-            "baz", "bar",
-          ],
-        },
-      ])), None),
-("
+			      ",
+            Some(serde_json::json!([
+              {
+                "definedTags": [
+                  "baz", "bar",
+                ],
+              },
+            ])),
+            None,
+        ),
+        (
+            "
 			          /**
 			           * @baz @bar foo (pass: invalid names but user preferred)
 			           */
 			          function quux (foo) {
-			
+
 			          }
-			      ", None, Some(serde_json::json!({
-        "settings": { "jsdoc": {
-          "tagNamePreference": {
-            "param": "baz",
-            "returns": {
-              "message": "Prefer `bar`",
-              "replacement": "bar",
-            },
-            "todo": false,
-          },
-        }},
-      }))),
-("
+			      ",
+            None,
+            Some(serde_json::json!({
+              "settings": { "jsdoc": {
+                "tagNamePreference": {
+                  "param": "baz",
+                  "returns": {
+                    "message": "Prefer `bar`",
+                    "replacement": "bar",
+                  },
+                  "todo": false,
+                },
+              }},
+            })),
+        ),
+        (
+            "
 			          /**
 			           * @arg foo (pass: invalid name but user preferred)
 			           */
 			          function quux (foo) {
-			
+
 			          }
-			      ", None, Some(serde_json::json!({
-        "settings" : { "jsdoc": {
-          "tagNamePreference": {
-            "param": "arg",
-          },
-        }},
-      }))),
-("
+			      ",
+            None,
+            Some(serde_json::json!({
+              "settings" : { "jsdoc": {
+                "tagNamePreference": {
+                  "param": "arg",
+                },
+              }},
+            })),
+        ),
+        (
+            "
 			      /**
 			       * @returns (pass: valid name)
 			       */
 			      function quux (foo) {}
-			      ", None, None),
-("", None, None),
-("
+			      ",
+            None,
+            None,
+        ),
+        ("", None, None),
+        (
+            "
 			          /**
 			           * (pass: no tag)
 			           */
 			          function quux (foo) {
-			
+
 			          }
-			      ", None, None),
-("
+			      ",
+            None,
+            None,
+        ),
+        (
+            "
 			          /**
 			           * @todo (pass: valid name)
 			           */
 			          function quux () {
-			
+
 			          }
-			      ", None, None),
-("
+			      ",
+            None,
+            None,
+        ),
+        (
+            "
 			          /**
 			           * @extends Foo (pass: invalid name but user preferred)
 			           */
 			          function quux () {
-			
+
 			          }
-			      ", None, Some(serde_json::json!({
-        "settings" : { "jsdoc": {
-          "tagNamePreference": {
-            "augments": {
-              "message": "@extends is to be used over @augments.",
-              "replacement": "extends",
-            },
-          },
-        }},
-      }))),
-("
+			      ",
+            None,
+            Some(serde_json::json!({
+              "settings" : { "jsdoc": {
+                "tagNamePreference": {
+                  "augments": {
+                    "message": "@extends is to be used over @augments.",
+                    "replacement": "extends",
+                  },
+                },
+              }},
+            })),
+        ),
+        (
+            "
 			          /**
 			           * (Set tag name preference to itself to get aliases to
 			           *   work along with main tag name.)
@@ -418,14 +452,18 @@ fn test() {
 			           */
 			          function quux () {
 			          }
-			      ", None, Some(serde_json::json!({
-        "settings" : { "jsdoc": {
-          "tagNamePreference": {
-            "extends": "extends",
-          },
-        }},
-      }))),
-("
+			      ",
+            None,
+            Some(serde_json::json!({
+              "settings" : { "jsdoc": {
+                "tagNamePreference": {
+                  "extends": "extends",
+                },
+              }},
+            })),
+        ),
+        (
+            "
 			      /**
 			       * Registers the `target` class as a transient dependency; each time the dependency is resolved a new instance will be created.
 			       *
@@ -440,32 +478,47 @@ fn test() {
 			      export function transient<T>(target?: T): T {
 			        // ...
 			      }
-			", None, None),
-("
+			",
+            None,
+            None,
+        ),
+        (
+            "
 			        /** @jsx h */
 			        /** @jsxFrag Fragment */
 			        /** @jsxImportSource preact */
 			        /** @jsxRuntime automatic (pass: valid jsx names)*/
-			      ", Some(serde_json::json!([
-        {
-          "jsxTags": true,
-        },
-      ])), None),
-("
+			      ",
+            Some(serde_json::json!([
+              {
+                "jsxTags": true,
+              },
+            ])),
+            None,
+        ),
+        (
+            "
 			      /**
 			       * @internal (pass: valid name)
 			       */
-			      ", None, Some(serde_json::json!({
-        "settings" : { "jsdoc": { }},
-      }))),
-("
+			      ",
+            None,
+            Some(serde_json::json!({
+              "settings" : { "jsdoc": { }},
+            })),
+        ),
+        (
+            "
 			        /**
 			         * @overload
 			         * @satisfies (pass: valid names)
 			         */
-			      ", None, Some(serde_json::json!({
-        "settings" : { "jsdoc": { }},
-      }))),
+			      ",
+            None,
+            Some(serde_json::json!({
+              "settings" : { "jsdoc": { }},
+            })),
+        ),
         (
             "
 			        /**
@@ -477,30 +530,42 @@ fn test() {
             None,
         ),
         // Typed
-        ("
+        (
+            "
       			        /** @default 0 */
       			        let a;
-      			      ", Some(serde_json::json!([
-        {
-          "typed": true,
-        },
-      ])), None),
-("
+      			      ",
+            Some(serde_json::json!([
+              {
+                "typed": true,
+              },
+            ])),
+            None,
+        ),
+        (
+            "
 			        /** @template name */
 			        let a;
-			      ", Some(serde_json::json!([
-        {
-          "typed": true,
-        },
-      ])), None),
-("
+			      ",
+            Some(serde_json::json!([
+              {
+                "typed": true,
+              },
+            ])),
+            None,
+        ),
+        (
+            "
 			        /** @param param - takes information */
 			        function takesOne(param) {}
-			      ", Some(serde_json::json!([
-        {
-          "typed": true,
-        },
-      ])), None),
+			      ",
+            Some(serde_json::json!([
+              {
+                "typed": true,
+              },
+            ])),
+            None,
+        ),
     ];
 
     let fail = vec![
@@ -518,7 +583,7 @@ fn test() {
         			           * @Param (fail: invalid name)
         			           */
         			          function quux () {
-			
+
         			          }
         			      ",
             None,
@@ -530,7 +595,7 @@ fn test() {
         			           * @foo (fail: invalid name)
         			           */
         			          function quux () {
-			
+
         			          }
         			      ",
             None,
@@ -542,7 +607,7 @@ fn test() {
         			           * @arg foo (fail: invalid name, default aliased)
         			           */
         			          function quux (foo) {
-			
+
         			          }
         			      ",
             None,
diff --git a/crates/oxc_linter/src/rules/jsdoc/empty_tags.rs b/crates/oxc_linter/src/rules/jsdoc/empty_tags.rs
index d7d9d564ff1a..11d5fd5ab0db 100644
--- a/crates/oxc_linter/src/rules/jsdoc/empty_tags.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/empty_tags.rs
@@ -1,7 +1,5 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::phf_set;
@@ -9,10 +7,13 @@ use serde::Deserialize;
 
 use crate::{context::LintContext, rule::Rule, utils::should_ignore_as_private};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsdoc(empty-tags): Expects the void tags to be empty of any content.")]
-#[diagnostic(severity(warning), help("`@{1}` tag should not have body."))]
-struct EmptyTagsDiagnostic(#[label] Span, String);
+fn empty_tags_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsdoc(empty-tags): Expects the void tags to be empty of any content.",
+    )
+    .with_help(format!("`@{x1}` tag should not have body."))
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct EmptyTags(Box<EmptyTagsConfig>);
@@ -125,10 +126,7 @@ impl Rule for EmptyTags {
                     continue;
                 }
 
-                ctx.diagnostic(EmptyTagsDiagnostic(
-                    comment.span_trimmed_first_line(),
-                    tag_name.to_string(),
-                ));
+                ctx.diagnostic(empty_tags_diagnostic(comment.span_trimmed_first_line(), tag_name));
             }
         }
     }
@@ -145,7 +143,7 @@ fn test() {
 			           * @abstract
 			           */
 			          function quux () {
-			
+
 			          }
 			      ",
             None,
@@ -157,7 +155,7 @@ fn test() {
 			           *
 			           */
 			          function quux () {
-			
+
 			          }
 			      ",
             None,
@@ -169,7 +167,7 @@ fn test() {
 			           * @param aName
 			           */
 			          function quux () {
-			
+
 			          }
 			      ",
             None,
@@ -183,7 +181,7 @@ fn test() {
 			           * @async
 			           */
 			          function quux () {
-			
+
 			          }
 			      ",
             None,
@@ -211,7 +209,7 @@ fn test() {
 			       * @private
 			       */
 			      function quux () {
-			
+
 			      }
 			      ",
             None,
@@ -223,7 +221,7 @@ fn test() {
 			       * @internal
 			       */
 			      function quux () {
-			
+
 			      }
 			      ",
             None,
@@ -254,7 +252,7 @@ fn test() {
 			           * @abstract extra text
 			           */
 			          function quux () {
-			
+
 			          }
 			      ",
             None,
@@ -280,7 +278,7 @@ fn test() {
 			           * @abstract extra text
 			           */
 			          quux () {
-			
+
 			          }
 			      }
 			      ",
@@ -295,7 +293,7 @@ fn test() {
 			           * @async out of place
 			           */
 			          function quux () {
-			
+
 			          }
 			      ",
             None,
@@ -307,7 +305,7 @@ fn test() {
 			           * @event anEvent
 			           */
 			          function quux () {
-			
+
 			          }
 			      ",
             Some(serde_json::json!([
@@ -326,7 +324,7 @@ fn test() {
 			       * bar
 			       */
 			      function quux () {
-			
+
 			      }
 			      ",
             None,
@@ -339,7 +337,7 @@ fn test() {
                    * foo
 			       */
 			      function quux () {
-			
+
 			      }
 			      ",
             None,
@@ -351,7 +349,7 @@ fn test() {
 			       * @private {someType}
 			       */
 			      function quux () {
-			
+
 			      }
 			      ",
             None,
diff --git a/crates/oxc_linter/src/rules/jsdoc/implements_on_classes.rs b/crates/oxc_linter/src/rules/jsdoc/implements_on_classes.rs
index 288287dba4b7..3fe116837e9a 100644
--- a/crates/oxc_linter/src/rules/jsdoc/implements_on_classes.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/implements_on_classes.rs
@@ -6,19 +6,16 @@ use crate::{
     AstNode,
 };
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jsdoc(implements-on-classes): `@implements` used on a non-constructor function"
-)]
-#[diagnostic(severity(warning), help("Add `@class` tag or use ES6 class syntax."))]
-struct ImplementsOnClassesDiagnostic(#[label] pub Span);
+fn implements_on_classes_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsdoc(implements-on-classes): `@implements` used on a non-constructor function")
+        .with_help("Add `@class` tag or use ES6 class syntax.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ImplementsOnClasses;
@@ -116,7 +113,7 @@ impl Rule for ImplementsOnClasses {
 
         if let Some(span) = implements_found {
             if !class_or_ctor_found {
-                ctx.diagnostic(ImplementsOnClassesDiagnostic(span));
+                ctx.diagnostic(implements_on_classes_diagnostic(span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsdoc/no_defaults.rs b/crates/oxc_linter/src/rules/jsdoc/no_defaults.rs
index 20bc206a54c7..2fd0cf552bc5 100644
--- a/crates/oxc_linter/src/rules/jsdoc/no_defaults.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/no_defaults.rs
@@ -1,7 +1,5 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use serde::Deserialize;
@@ -14,10 +12,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsdoc(no-defaults): Defaults are not permitted.")]
-#[diagnostic(severity(warning), help("{1}"))]
-struct NoDefaultsDiagnostic(#[label] pub Span, String);
+fn no_defaults_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsdoc(no-defaults): Defaults are not permitted.")
+        .with_help(x1.to_string())
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDefaults(Box<NoDefaultsConfig>);
@@ -97,13 +96,13 @@ impl Rule for NoDefaults {
                 }
 
                 match (config.no_optional_param_names, name_part.default) {
-                    (true, _) => ctx.diagnostic(NoDefaultsDiagnostic(
+                    (true, _) => ctx.diagnostic(no_defaults_diagnostic(
                         name_part.span,
-                        format!("Optional param names are not permitted on `@{tag_name}` tag."),
+                        &format!("Optional param names are not permitted on `@{tag_name}` tag."),
                     )),
-                    (false, true) => ctx.diagnostic(NoDefaultsDiagnostic(
+                    (false, true) => ctx.diagnostic(no_defaults_diagnostic(
                         name_part.span,
-                        format!("Defaults are not permitted on `@{tag_name}` tag."),
+                        &format!("Defaults are not permitted on `@{tag_name}` tag."),
                     )),
                     (false, false) => {}
                 }
@@ -123,7 +122,7 @@ fn test() {
 			           * @param foo
 			           */
 			          function quux (foo) {
-			
+
 			          }
 			      ",
             None,
@@ -135,7 +134,7 @@ fn test() {
 			           * @param {number} foo
 			           */
 			          function quux (foo) {
-			
+
 			          }
 			      ",
             None,
@@ -148,7 +147,7 @@ fn test() {
 			           * @param {number} [bar]
 			           */
 			          function quux (foo) {
-			
+
 			          }
 			      ",
             None,
@@ -195,7 +194,7 @@ fn test() {
 			           * @param {number} foo
 			           */
 			          function quux (foo) {
-			
+
 			          }
 			      ",
             Some(serde_json::json!([
@@ -230,7 +229,7 @@ fn test() {
 			           * @param {number} [foo="7"]
 			           */
 			          function quux (foo) {
-			
+
 			          }
 			      "#,
             None,
@@ -243,7 +242,7 @@ fn test() {
 			           * @param {number} [bar = 1]
 			           */
 			          const quux = (foo, bar = 1) => {
-			
+
 			          }
 			      ",
             None,
@@ -256,7 +255,7 @@ fn test() {
 			           * @param {number} [foo="7"]
 			           */
 			          quux (foo) {
-			
+
 			          }
 			      }
 			      "#,
@@ -269,7 +268,7 @@ fn test() {
 			           * @param {number} [foo="7"]
 			           */
 			          function quux (foo) {
-			
+
 			          }
 			      "#,
             Some(serde_json::json!([
@@ -285,7 +284,7 @@ fn test() {
 			           * @param {number} [foo]
 			           */
 			          function quux (foo) {
-			
+
 			          }
 			      ",
             Some(serde_json::json!([
@@ -301,7 +300,7 @@ fn test() {
 			           * @arg {number} [foo="7"]
 			           */
 			          function quux (foo) {
-			
+
 			          }
 			      "#,
             None,
diff --git a/crates/oxc_linter/src/rules/jsdoc/require_property.rs b/crates/oxc_linter/src/rules/jsdoc/require_property.rs
index 97bef7450e2e..27f8db98320a 100644
--- a/crates/oxc_linter/src/rules/jsdoc/require_property.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/require_property.rs
@@ -1,7 +1,5 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -11,14 +9,11 @@ use crate::{
     utils::{should_ignore_as_internal, should_ignore_as_private},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsdoc(require-property): The `@typedef` and `@namespace` tags must include a `@property` tag with the type Object.")]
-#[diagnostic(
-    severity(warning),
-    help("Consider adding a `@property` tag or replacing it with a more specific type.")
-)]
-
-struct RequirePropertyDiagnostic(#[label] pub Span);
+fn require_property_diagnostic(span: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsdoc(require-property): The `@typedef` and `@namespace` tags must include a `@property` tag with the type Object.")
+        .with_help("Consider adding a `@property` tag or replacing it with a more specific type.")
+        .and_label(span)
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct RequireProperty;
@@ -79,7 +74,7 @@ impl Rule for RequireProperty {
                     // - This JSDoc has multiple `@typedef` or `@namespace` tags
                     // - And previous `@typedef` or `@namespace` tag did not have `@property` tag
                     if let Some(span) = should_report {
-                        ctx.diagnostic(RequirePropertyDiagnostic(span));
+                        ctx.diagnostic(require_property_diagnostic(span));
                     }
 
                     let (Some(type_part), _, _) = tag.type_name_comment() else {
@@ -99,7 +94,7 @@ impl Rule for RequireProperty {
             }
 
             if let Some(span) = should_report {
-                ctx.diagnostic(RequirePropertyDiagnostic(span));
+                ctx.diagnostic(require_property_diagnostic(span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsdoc/require_property_description.rs b/crates/oxc_linter/src/rules/jsdoc/require_property_description.rs
index 3c09cccb1aa0..8d8ded15b2ed 100644
--- a/crates/oxc_linter/src/rules/jsdoc/require_property_description.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/require_property_description.rs
@@ -1,7 +1,5 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -11,10 +9,13 @@ use crate::{
     utils::{should_ignore_as_internal, should_ignore_as_private},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsdoc(require-property-description): Missing description in @property tag.")]
-#[diagnostic(severity(warning), help("Add a description to this @property tag."))]
-struct RequirePropertyDescriptionDiagnostic(#[label] pub Span);
+fn require_property_description_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsdoc(require-property-description): Missing description in @property tag.",
+    )
+    .with_help("Add a description to this @property tag.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct RequirePropertyDescription;
@@ -67,7 +68,7 @@ impl Rule for RequirePropertyDescription {
                     continue;
                 };
 
-                ctx.diagnostic(RequirePropertyDescriptionDiagnostic(tag_name.span));
+                ctx.diagnostic(require_property_description_diagnostic(tag_name.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsdoc/require_property_name.rs b/crates/oxc_linter/src/rules/jsdoc/require_property_name.rs
index 853a4b14385e..2ac229a9ac14 100644
--- a/crates/oxc_linter/src/rules/jsdoc/require_property_name.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/require_property_name.rs
@@ -1,7 +1,5 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -11,10 +9,13 @@ use crate::{
     utils::{should_ignore_as_internal, should_ignore_as_private},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsdoc(require-property-name): Missing name in @property tag.")]
-#[diagnostic(severity(warning), help("Add a type name to this @property tag."))]
-struct RequirePropertyNameDiagnostic(#[label] pub Span);
+fn require_property_name_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsdoc(require-property-name): Missing name in @property tag.",
+    )
+    .with_help("Add a type name to this @property tag.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct RequirePropertyName;
@@ -67,7 +68,7 @@ impl Rule for RequirePropertyName {
                     continue;
                 };
 
-                ctx.diagnostic(RequirePropertyNameDiagnostic(tag_name.span));
+                ctx.diagnostic(require_property_name_diagnostic(tag_name.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsdoc/require_property_type.rs b/crates/oxc_linter/src/rules/jsdoc/require_property_type.rs
index 5412a79a335f..522e0cedea54 100644
--- a/crates/oxc_linter/src/rules/jsdoc/require_property_type.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/require_property_type.rs
@@ -1,7 +1,5 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -11,10 +9,13 @@ use crate::{
     utils::{should_ignore_as_internal, should_ignore_as_private},
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsdoc(require-property-type): Missing type in @property tag.")]
-#[diagnostic(severity(warning), help("Add a {{type}} to this @property tag."))]
-struct RequirePropertyTypeDiagnostic(#[label] pub Span);
+fn require_property_type_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsdoc(require-property-type): Missing type in @property tag.",
+    )
+    .with_help("Add a {type} to this @property tag.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct RequirePropertyType;
@@ -67,7 +68,7 @@ impl Rule for RequirePropertyType {
                     continue;
                 };
 
-                ctx.diagnostic(RequirePropertyTypeDiagnostic(tag_name.span));
+                ctx.diagnostic(require_property_type_diagnostic(tag_name.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsdoc/require_yields.rs b/crates/oxc_linter/src/rules/jsdoc/require_yields.rs
index a0473661360f..7a8c95e1e857 100644
--- a/crates/oxc_linter/src/rules/jsdoc/require_yields.rs
+++ b/crates/oxc_linter/src/rules/jsdoc/require_yields.rs
@@ -1,8 +1,6 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{JSDoc, JSDocTag};
 use oxc_span::Span;
@@ -19,19 +17,22 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum RequireYieldsDiagnostic {
-    #[error("eslint-plugin-jsdoc(require-yields): Missing JSDoc `@yields` declaration for generator function.")]
-    #[diagnostic(severity(warning), help("Add `@yields` tag to the JSDoc comment."))]
-    MissingYields(#[label] Span),
-    #[error("eslint-plugin-jsdoc(require-yields): Duplicate `@yields` tags.")]
-    #[diagnostic(severity(warning), help("Remove redundunt `@yields` tag."))]
-    DuplicateYields(#[label] Span),
-    #[error(
-        "eslint-plugin-jsdoc(require-yields): `@yields` tag is required when using `@generator` tag."
-    )]
-    #[diagnostic(severity(warning), help("Add `@yields` tag to the JSDoc comment."))]
-    MissingYieldsWithGenerator(#[label] Span),
+fn missing_yields(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsdoc(require-yields): Missing JSDoc `@yields` declaration for generator function.")
+        .with_help("Add `@yields` tag to the JSDoc comment.")
+        .with_labels([span0.into()])
+}
+
+fn duplicate_yields(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsdoc(require-yields): Duplicate `@yields` tags.")
+        .with_help("Remove redundunt `@yields` tag.")
+        .with_labels([span0.into()])
+}
+
+fn missing_yields_with_generator(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsdoc(require-yields): `@yields` tag is required when using `@generator` tag.")
+        .with_help("Add `@yields` tag to the JSDoc comment.")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -144,7 +145,7 @@ impl Rule for RequireYields {
                 if config.force_require_yields
                     && is_missing_yields_tag(&jsdoc_tags, &resolved_yields_tag_name)
                 {
-                    ctx.diagnostic(RequireYieldsDiagnostic::MissingYields(func.span));
+                    ctx.diagnostic(missing_yields(func.span));
                     return;
                 }
 
@@ -152,7 +153,7 @@ impl Rule for RequireYields {
 
                 if let Some(span) = is_duplicated_yields_tag(&jsdoc_tags, &resolved_yields_tag_name)
                 {
-                    ctx.diagnostic(RequireYieldsDiagnostic::DuplicateYields(span));
+                    ctx.diagnostic(duplicate_yields(span));
                     return;
                 }
 
@@ -164,7 +165,7 @@ impl Rule for RequireYields {
                         &resolved_yields_tag_name,
                         &resolved_generator_tag_name,
                     ) {
-                        ctx.diagnostic(RequireYieldsDiagnostic::MissingYieldsWithGenerator(span));
+                        ctx.diagnostic(missing_yields_with_generator(span));
                     }
                 }
             }
@@ -230,7 +231,7 @@ impl Rule for RequireYields {
                 let resolved_yields_tag_name = settings.resolve_tag_name("yields");
 
                 if is_missing_yields_tag(&jsdoc_tags, &resolved_yields_tag_name) {
-                    ctx.diagnostic(RequireYieldsDiagnostic::MissingYields(generator_func.span));
+                    ctx.diagnostic(missing_yields(generator_func.span));
                 }
             }
             _ => {}
@@ -302,7 +303,7 @@ fn test() {
         			           * @yields Foo.
         			           */
         			          function * quux () {
-			
+
         			            yield foo;
         			          }
         			      ",
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/alt_text.rs b/crates/oxc_linter/src/rules/jsx_a11y/alt_text.rs
index c956dc447d1f..2c155c19bcc7 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/alt_text.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/alt_text.rs
@@ -2,10 +2,7 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeValue, JSXElement, JSXOpeningElement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -15,49 +12,56 @@ use crate::utils::{
 };
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum AltTextDiagnostic {
-    // <img>
-    #[error("eslint-plugin-jsx-a11y(alt-text): Missing `alt` attribute.")]
-    #[diagnostic(severity(warning), help("Must have `alt` prop, either with meaningful text, or an empty string for decorative images."))]
-    MissingAltProp(#[label] Span),
-
-    #[error("eslint-plugin-jsx-a11y(alt-text): Invalid `alt` value.")]
-    #[diagnostic(
-        severity(warning),
-        help("Must have meaningful value for `alt` prop. Use alt=\"\" for presentational images.")
-    )]
-    MissingAltValue(#[label] Span),
-
-    #[error("eslint-plugin-jsx-a11y(alt-text): Missing value for aria-label attribute.")]
-    #[diagnostic(severity(warning), help("The aria-label attribute must have a value. The alt attribute is preferred over aria-label for images."))]
-    AriaLabelValue(#[label] Span),
-
-    #[error("eslint-plugin-jsx-a11y(alt-text): Missing value for aria-labelledby attribute.")]
-    #[diagnostic(
-        severity(warning),
-        help("The alt attribute is preferred over aria-labelledby for images.")
-    )]
-    AriaLabelledByValue(#[label] Span),
-
-    #[error("eslint-plugin-jsx-a11y(alt-text): ARIA used where native HTML could suffice.")]
-    #[diagnostic(severity(warning), help("Prefer alt=\"\" over presentational role. Native HTML attributes should be preferred for accessibility before resorting to ARIA attributes."))]
-    PreferAlt(#[label] Span),
-
-    // <object>
-    #[error("eslint-plugin-jsx-a11y(alt-text): Missing alternative text.")]
-    #[diagnostic(severity(warning), help("Embedded <object> elements must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop."))]
-    Object(#[label] Span),
-
-    // <area>
-    #[error("eslint-plugin-jsx-a11y(alt-text): Missing alternative text.")]
-    #[diagnostic(severity(warning), help("Each area of an image map must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop."))]
-    Area(#[label] Span),
-
-    // <input type="image">
-    #[error("eslint-plugin-jsx-a11y(alt-text): Missing alternative text.")]
-    #[diagnostic(severity(warning), help("<input> elements with type=\"image\" must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop."))]
-    InputTypeImage(#[label] Span),
+fn missing_alt_prop(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(alt-text): Missing `alt` attribute.")
+        .with_help("Must have `alt` prop, either with meaningful text, or an empty string for decorative images.")
+        .with_labels([span0.into()])
+}
+
+fn missing_alt_value(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(alt-text): Invalid `alt` value.")
+        .with_help(
+            "Must have meaningful value for `alt` prop. Use alt=\"\" for presentational images.",
+        )
+        .with_labels([span0.into()])
+}
+
+fn aria_label_value(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(alt-text): Missing value for aria-label attribute.")
+        .with_help("The aria-label attribute must have a value. The alt attribute is preferred over aria-label for images.")
+        .with_labels([span0.into()])
+}
+
+fn aria_labelled_by_value(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsx-a11y(alt-text): Missing value for aria-labelledby attribute.",
+    )
+    .with_help("The alt attribute is preferred over aria-labelledby for images.")
+    .with_labels([span0.into()])
+}
+
+fn prefer_alt(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(alt-text): ARIA used where native HTML could suffice.")
+        .with_help("Prefer alt=\"\" over presentational role. Native HTML attributes should be preferred for accessibility before resorting to ARIA attributes.")
+        .with_labels([span0.into()])
+}
+
+fn object(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(alt-text): Missing alternative text.")
+        .with_help("Embedded <object> elements must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.")
+        .with_labels([span0.into()])
+}
+
+fn area(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(alt-text): Missing alternative text.")
+        .with_help("Each area of an image map must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.")
+        .with_labels([span0.into()])
+}
+
+fn input_type_image(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(alt-text): Missing alternative text.")
+        .with_help("<input> elements with type=\"image\" must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -162,8 +166,12 @@ impl Rule for AltText {
     }
 
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else { return };
-        let Some(name) = &get_element_type(ctx, jsx_el) else { return };
+        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else {
+            return;
+        };
+        let Some(name) = &get_element_type(ctx, jsx_el) else {
+            return;
+        };
 
         // <img>
         if let Some(custom_tags) = &self.img {
@@ -239,31 +247,31 @@ fn aria_label_has_value<'a>(item: &'a JSXAttributeItem<'a>) -> bool {
 fn img_rule<'a>(node: &'a JSXOpeningElement<'a>, ctx: &LintContext<'a>) {
     if let Some(alt_prop) = has_jsx_prop_lowercase(node, "alt") {
         if !is_valid_alt_prop(alt_prop) {
-            ctx.diagnostic(AltTextDiagnostic::MissingAltValue(node.span));
+            ctx.diagnostic(missing_alt_value(node.span));
         }
         return;
     }
 
     if has_jsx_prop_lowercase(node, "role").map_or(false, is_presentation_role) {
-        ctx.diagnostic(AltTextDiagnostic::PreferAlt(node.span));
+        ctx.diagnostic(prefer_alt(node.span));
         return;
     }
 
     if let Some(aria_label_prop) = has_jsx_prop_lowercase(node, "aria-label") {
         if !aria_label_has_value(aria_label_prop) {
-            ctx.diagnostic(AltTextDiagnostic::AriaLabelValue(node.span));
+            ctx.diagnostic(aria_label_value(node.span));
         }
         return;
     }
 
     if let Some(aria_labelledby_prop) = has_jsx_prop_lowercase(node, "aria-labelledby") {
         if !aria_label_has_value(aria_labelledby_prop) {
-            ctx.diagnostic(AltTextDiagnostic::AriaLabelledByValue(node.span));
+            ctx.diagnostic(aria_labelled_by_value(node.span));
         }
         return;
     }
 
-    ctx.diagnostic(AltTextDiagnostic::MissingAltProp(node.span));
+    ctx.diagnostic(missing_alt_prop(node.span));
 }
 
 fn object_rule<'a>(
@@ -283,7 +291,7 @@ fn object_rule<'a>(
     if has_label || has_title_attr || object_has_accessible_child(ctx, parent) {
         return;
     }
-    ctx.diagnostic(AltTextDiagnostic::Object(node.span));
+    ctx.diagnostic(object(node.span));
 }
 
 fn area_rule<'a>(node: &'a JSXOpeningElement<'a>, ctx: &LintContext<'a>) {
@@ -297,11 +305,11 @@ fn area_rule<'a>(node: &'a JSXOpeningElement<'a>, ctx: &LintContext<'a>) {
     }
     has_jsx_prop_lowercase(node, "alt").map_or_else(
         || {
-            ctx.diagnostic(AltTextDiagnostic::Area(node.span));
+            ctx.diagnostic(area(node.span));
         },
         |alt_prop| {
             if !is_valid_alt_prop(alt_prop) {
-                ctx.diagnostic(AltTextDiagnostic::Area(node.span));
+                ctx.diagnostic(area(node.span));
             }
         },
     );
@@ -318,11 +326,11 @@ fn input_type_image_rule<'a>(node: &'a JSXOpeningElement<'a>, ctx: &LintContext<
     }
     has_jsx_prop_lowercase(node, "alt").map_or_else(
         || {
-            ctx.diagnostic(AltTextDiagnostic::InputTypeImage(node.span));
+            ctx.diagnostic(input_type_image(node.span));
         },
         |alt_prop| {
             if !is_valid_alt_prop(alt_prop) {
-                ctx.diagnostic(AltTextDiagnostic::InputTypeImage(node.span));
+                ctx.diagnostic(input_type_image(node.span));
             }
         },
     );
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/anchor_has_content.rs b/crates/oxc_linter/src/rules/jsx_a11y/anchor_has_content.rs
index 153a1790c01b..0f9e87025efa 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/anchor_has_content.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/anchor_has_content.rs
@@ -1,8 +1,5 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,18 +13,16 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum AnchorHasContentDiagnostic {
-    #[error("eslint-plugin-jsx-a11y(anchor-has-content): Missing accessible content when using `a` elements.")]
-    #[diagnostic(
-        severity(warning),
-        help("Provide screen reader accessible content when using `a` elements.")
-    )]
-    MissingContent(#[label] Span),
+fn missing_content(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(anchor-has-content): Missing accessible content when using `a` elements.")
+        .with_help("Provide screen reader accessible content when using `a` elements.")
+        .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-jsx-a11y(anchor-has-content): Missing accessible content when using `a` elements.")]
-    #[diagnostic(severity(warning), help("Remove the `aria-hidden` attribute to allow the anchor element and its content visible to assistive technologies."))]
-    RemoveAriaHidden(#[label] Span),
+fn remove_aria_hidden(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(anchor-has-content): Missing accessible content when using `a` elements.")
+        .with_help("Remove the `aria-hidden` attribute to allow the anchor element and its content visible to assistive technologies.")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -70,10 +65,12 @@ declare_oxc_lint!(
 impl Rule for AnchorHasContent {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::JSXElement(jsx_el) = node.kind() {
-            let Some(name) = &get_element_type(ctx, &jsx_el.opening_element) else { return };
+            let Some(name) = &get_element_type(ctx, &jsx_el.opening_element) else {
+                return;
+            };
             if name == "a" {
                 if is_hidden_from_screen_reader(ctx, &jsx_el.opening_element) {
-                    ctx.diagnostic(AnchorHasContentDiagnostic::RemoveAriaHidden(jsx_el.span));
+                    ctx.diagnostic(remove_aria_hidden(jsx_el.span));
                     return;
                 }
 
@@ -87,7 +84,7 @@ impl Rule for AnchorHasContent {
                     };
                 }
 
-                ctx.diagnostic(AnchorHasContentDiagnostic::MissingContent(jsx_el.span));
+                ctx.diagnostic(missing_content(jsx_el.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/anchor_is_valid.rs b/crates/oxc_linter/src/rules/jsx_a11y/anchor_is_valid.rs
index 9d41f2d80555..231dfebf1737 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/anchor_is_valid.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/anchor_is_valid.rs
@@ -2,10 +2,7 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeValue, JSXElementName, JSXExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,21 +13,28 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum AnchorIsValidDiagnostic {
-    #[error(
-        "eslint-plugin-jsx-a11y(anchor-is-valid): Missing `href` attribute for the `a` element."
-    )]
-    #[diagnostic(severity(warning), help("Provide an href for the `a` element."))]
-    MissingHrefAttribute(#[label] Span),
+fn missing_href_attribute(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsx-a11y(anchor-is-valid): Missing `href` attribute for the `a` element.",
+    )
+    .with_help("Provide an href for the `a` element.")
+    .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-jsx-a11y(anchor-is-valid): Use an incorrect href for the 'a' element.")]
-    #[diagnostic(severity(warning), help("Provide a correct href for the `a` element."))]
-    IncorrectHref(#[label] Span),
+fn incorrect_href(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsx-a11y(anchor-is-valid): Use an incorrect href for the 'a' element.",
+    )
+    .with_help("Provide a correct href for the `a` element.")
+    .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-jsx-a11y(anchor-is-valid):  The a element has `href` and `onClick`.")]
-    #[diagnostic(severity(warning), help("Use a `button` element instead of an `a` element."))]
-    CantBeAnchor(#[label] Span),
+fn cant_be_anchor(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsx-a11y(anchor-is-valid):  The a element has `href` and `onClick`.",
+    )
+    .with_help("Use a `button` element instead of an `a` element.")
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -128,8 +132,12 @@ impl Rule for AnchorIsValid {
 
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::JSXElement(jsx_el) = node.kind() {
-            let JSXElementName::Identifier(ident) = &jsx_el.opening_element.name else { return };
-            let Some(name) = &get_element_type(ctx, &jsx_el.opening_element) else { return };
+            let JSXElementName::Identifier(ident) = &jsx_el.opening_element.name else {
+                return;
+            };
+            let Some(name) = &get_element_type(ctx, &jsx_el.opening_element) else {
+                return;
+            };
             if name == "a" {
                 if let Option::Some(herf_attr) =
                     has_jsx_prop_lowercase(&jsx_el.opening_element, "href")
@@ -143,19 +151,15 @@ impl Rule for AnchorIsValid {
                                     if has_jsx_prop_lowercase(&jsx_el.opening_element, "onclick")
                                         .is_some()
                                     {
-                                        ctx.diagnostic(AnchorIsValidDiagnostic::CantBeAnchor(
-                                            ident.span,
-                                        ));
+                                        ctx.diagnostic(cant_be_anchor(ident.span));
                                         return;
                                     }
-                                    ctx.diagnostic(AnchorIsValidDiagnostic::IncorrectHref(
-                                        ident.span,
-                                    ));
+                                    ctx.diagnostic(incorrect_href(ident.span));
                                     return;
                                 }
                             }
                             None => {
-                                ctx.diagnostic(AnchorIsValidDiagnostic::IncorrectHref(ident.span));
+                                ctx.diagnostic(incorrect_href(ident.span));
                                 return;
                             }
                         },
@@ -175,7 +179,7 @@ impl Rule for AnchorIsValid {
                 if has_spreed_attr {
                     return;
                 }
-                ctx.diagnostic(AnchorIsValidDiagnostic::MissingHrefAttribute(ident.span));
+                ctx.diagnostic(missing_href_attribute(ident.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/aria_activedescendant_has_tabindex.rs b/crates/oxc_linter/src/rules/jsx_a11y/aria_activedescendant_has_tabindex.rs
index 98ad800e7e47..19c533b8cb1d 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/aria_activedescendant_has_tabindex.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/aria_activedescendant_has_tabindex.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{JSXAttribute, JSXAttributeItem, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -17,13 +15,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(aria-activedescendant-has-tabindex): Enforce elements with aria-activedescendant are tabbable.")]
-#[diagnostic(
-    severity(warning),
-    help("An element that manages focus with `aria-activedescendant` must have a tabindex.")
-)]
-struct AriaActivedescendantHasTabindexDiagnostic(#[label] pub Span);
+fn aria_activedescendant_has_tabindex_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(aria-activedescendant-has-tabindex): Enforce elements with aria-activedescendant are tabbable.")
+        .with_help("An element that manages focus with `aria-activedescendant` must have a tabindex.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct AriaActivedescendantHasTabindex;
@@ -91,7 +87,7 @@ impl Rule for AriaActivedescendantHasTabindex {
             return;
         };
 
-        ctx.diagnostic(AriaActivedescendantHasTabindexDiagnostic(identifier.span));
+        ctx.diagnostic(aria_activedescendant_has_tabindex_diagnostic(identifier.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/aria_props.rs b/crates/oxc_linter/src/rules/jsx_a11y/aria_props.rs
index bae7fba659c8..5a26a45b42b5 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/aria_props.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/aria_props.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::JSXAttributeItem, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -11,10 +9,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(aria-props): Invalid ARIA prop.")]
-#[diagnostic(severity(warning), help("`{1}` is an invalid ARIA attribute."))]
-struct AriaPropsDiagnostic(#[label] pub Span, String);
+fn aria_props_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(aria-props): Invalid ARIA prop.")
+        .with_help(format!("`{x1}` is an invalid ARIA attribute."))
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct AriaProps;
@@ -44,7 +43,7 @@ impl Rule for AriaProps {
         if let AstKind::JSXAttributeItem(JSXAttributeItem::Attribute(attr)) = node.kind() {
             let name = get_jsx_attribute_name(&attr.name).to_lowercase();
             if name.starts_with("aria-") && !VALID_ARIA_PROPS.contains(&name) {
-                ctx.diagnostic(AriaPropsDiagnostic(attr.span, name));
+                ctx.diagnostic(aria_props_diagnostic(attr.span, &name));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/aria_role.rs b/crates/oxc_linter/src/rules/jsx_a11y/aria_role.rs
index 85234aa5f681..d8bd21e75e98 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/aria_role.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/aria_role.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{JSXAttributeValue, JSXExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -17,13 +15,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(aria-role): Elements with ARIA roles must use a valid, non-abstract ARIA role.")]
-#[diagnostic(
-    severity(warning),
-    help("Set a valid, non-abstract ARIA role for element with ARIA{1}")
-)]
-struct AriaRoleDiagnostic(#[label] pub Span, String);
+fn aria_role_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(aria-role): Elements with ARIA roles must use a valid, non-abstract ARIA role.")
+        .with_help(format!("Set a valid, non-abstract ARIA role for element with ARIA{x1}"))
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct AriaRole(Box<AriaRoleConfig>);
@@ -96,7 +92,9 @@ declare_oxc_lint!(
 
 impl Rule for AriaRole {
     fn from_configuration(value: serde_json::Value) -> Self {
-        let Some(value) = value.as_array() else { return Self::default() };
+        let Some(value) = value.as_array() else {
+            return Self::default();
+        };
         let mut ignore_non_dom = false;
         let mut allowed_invalid_roles: Vec<String> = vec![];
 
@@ -138,7 +136,7 @@ impl Rule for AriaRole {
                     Some(JSXAttributeValue::ExpressionContainer(container)) => {
                         let jsexp = &container.expression;
                         if matches!(jsexp, JSXExpression::NullLiteral(_)) || jsexp.is_undefined() {
-                            ctx.diagnostic(AriaRoleDiagnostic(attr.span, String::new()));
+                            ctx.diagnostic(aria_role_diagnostic(attr.span, ""));
                         }
                     }
                     Some(JSXAttributeValue::StringLiteral(str)) => {
@@ -148,14 +146,14 @@ impl Rule for AriaRole {
                             !VALID_ARIA_ROLES.contains(word)
                                 && !self.allowed_invalid_roles.contains(&(*word).to_string())
                         }) {
-                            ctx.diagnostic(AriaRoleDiagnostic(
+                            ctx.diagnostic(aria_role_diagnostic(
                                 str.span,
-                                format!(", `{error_prop}` is an invalid aria role"),
+                                &format!(", `{error_prop}` is an invalid aria role"),
                             ));
                         }
                     }
                     _ => {
-                        ctx.diagnostic(AriaRoleDiagnostic(attr.span, String::new()));
+                        ctx.diagnostic(aria_role_diagnostic(attr.span, ""));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/aria_unsupported_elements.rs b/crates/oxc_linter/src/rules/jsx_a11y/aria_unsupported_elements.rs
index 3d34b8830692..c05c3b29f9d9 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/aria_unsupported_elements.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/aria_unsupported_elements.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::JSXAttributeItem, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::phf_set;
@@ -36,10 +34,11 @@ declare_oxc_lint! {
 #[derive(Debug, Default, Clone)]
 pub struct AriaUnsupportedElements;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(aria-unsupported-elements): This element does not support ARIA roles, states and properties.")]
-#[diagnostic(severity(warning), help("Try removing the prop `{1}`."))]
-struct AriaUnsupportedElementsDiagnostic(#[label] pub Span, String);
+fn aria_unsupported_elements_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(aria-unsupported-elements): This element does not support ARIA roles, states and properties.")
+        .with_help(format!("Try removing the prop `{x1}`."))
+        .with_labels([span0.into()])
+}
 
 impl Rule for AriaUnsupportedElements {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
@@ -55,7 +54,7 @@ impl Rule for AriaUnsupportedElements {
                     };
                     let attr_name = get_jsx_attribute_name(&attr.name).to_lowercase();
                     if INVALID_ATTRIBUTES.contains(&attr_name) {
-                        ctx.diagnostic(AriaUnsupportedElementsDiagnostic(attr.span, attr_name));
+                        ctx.diagnostic(aria_unsupported_elements_diagnostic(attr.span, &attr_name));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/autocomplete_valid.rs b/crates/oxc_linter/src/rules/jsx_a11y/autocomplete_valid.rs
index c2d39752d9cf..c91a15dcbe1b 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/autocomplete_valid.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/autocomplete_valid.rs
@@ -8,22 +8,16 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeValue},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::{phf_map, phf_set};
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jsx-a11y(autocomplete-valid): `{autocomplete}` is not a valid value for autocomplete."
-)]
-#[diagnostic(severity(warning), help("Change `{autocomplete}` to a valid value for autocomplete."))]
-struct AutocompleteValidDiagnostic {
-    #[label]
-    pub span: Span,
-    pub autocomplete: String,
+
+fn autocomplete_valid_diagnostic(span: Span, autocomplete: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jsx-a11y(autocomplete-valid): `{autocomplete}` is not a valid value for autocomplete."))
+        .with_help(format!("Change `{autocomplete}` to a valid value for autocomplete."))
+        .with_label(span)
 }
 
 #[derive(Debug, Default, Clone)]
@@ -182,7 +176,9 @@ impl Rule for AutocompleteValid {
 
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::JSXOpeningElement(jsx_el) = node.kind() {
-            let Some(name) = &get_element_type(ctx, jsx_el) else { return };
+            let Some(name) = &get_element_type(ctx, jsx_el) else {
+                return;
+            };
             if !self.input_components.contains(name) {
                 return;
             }
@@ -197,12 +193,9 @@ impl Rule for AutocompleteValid {
             let Some(JSXAttributeValue::StringLiteral(autocomplete_values)) = &attr.value else {
                 return;
             };
-            let value = autocomplete_values.value.to_string();
-            if !is_valid_autocomplete_value(&value) {
-                ctx.diagnostic(AutocompleteValidDiagnostic {
-                    span: attr.span,
-                    autocomplete: value,
-                });
+            let value = &autocomplete_values.value;
+            if !is_valid_autocomplete_value(value) {
+                ctx.diagnostic(autocomplete_valid_diagnostic(attr.span, value));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/click_events_have_key_events.rs b/crates/oxc_linter/src/rules/jsx_a11y/click_events_have_key_events.rs
index 6a7402d3b2ef..574000a66ba8 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/click_events_have_key_events.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/click_events_have_key_events.rs
@@ -1,8 +1,6 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -17,10 +15,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(click-events-have-key-events): Enforce a clickable non-interactive element has at least one keyboard event listener.")]
-#[diagnostic(severity(warning), help("Visible, non-interactive elements with click handlers must have one of keyup, keydown, or keypress listener."))]
-struct ClickEventsHaveKeyEventsDiagnostic(#[label] pub Span);
+fn click_events_have_key_events_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(click-events-have-key-events): Enforce a clickable non-interactive element has at least one keyboard event listener.")
+        .with_help("Visible, non-interactive elements with click handlers must have one of keyup, keydown, or keypress listener.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ClickEventsHaveKeyEvents;
@@ -82,7 +81,7 @@ impl Rule for ClickEventsHaveKeyEvents {
             return;
         }
 
-        ctx.diagnostic(ClickEventsHaveKeyEventsDiagnostic(jsx_opening_el.span));
+        ctx.diagnostic(click_events_have_key_events_diagnostic(jsx_opening_el.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/heading_has_content.rs b/crates/oxc_linter/src/rules/jsx_a11y/heading_has_content.rs
index e3b757440db9..c76aa4ae4301 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/heading_has_content.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/heading_has_content.rs
@@ -1,8 +1,6 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -13,13 +11,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(heading-has-content): Headings must have content and the content must be accessible by a screen reader.")]
-#[diagnostic(
-    severity(warning),
-    help("Provide screen reader accessible content when using heading elements.")
-)]
-struct HeadingHasContentDiagnostic(#[label] pub Span);
+fn heading_has_content_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(heading-has-content): Headings must have content and the content must be accessible by a screen reader.")
+        .with_help("Provide screen reader accessible content when using heading elements.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct HeadingHasContent(Box<HeadingHasContentConfig>);
@@ -116,7 +112,7 @@ impl Rule for HeadingHasContent {
             return;
         }
 
-        ctx.diagnostic(HeadingHasContentDiagnostic(jsx_el.span));
+        ctx.diagnostic(heading_has_content_diagnostic(jsx_el.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/html_has_lang.rs b/crates/oxc_linter/src/rules/jsx_a11y/html_has_lang.rs
index 52adea4466fb..b783ad9b3029 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/html_has_lang.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/html_has_lang.rs
@@ -2,10 +2,7 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeValue, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,15 +13,18 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum HtmlHasLangDiagnostic {
-    #[error("eslint-plugin-jsx-a11y(html-has-lang): Missing lang attribute.")]
-    #[diagnostic(severity(warning), help("Add a lang attribute to the html element whose value represents the primary language of document."))]
-    MissingLangProp(#[label] Span),
+fn missing_lang_prop(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(html-has-lang): Missing lang attribute.")
+        .with_help("Add a lang attribute to the html element whose value represents the primary language of document.")
+        .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-jsx-a11y(html-has-lang): Missing value for lang attribute")]
-    #[diagnostic(severity(warning), help("Must have meaningful value for `lang` prop."))]
-    MissingLangValue(#[label] Span),
+fn missing_lang_value(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsx-a11y(html-has-lang): Missing value for lang attribute",
+    )
+    .with_help("Must have meaningful value for `lang` prop.")
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -73,10 +73,10 @@ impl Rule for HtmlHasLang {
         };
 
         has_jsx_prop_lowercase(jsx_el, "lang").map_or_else(
-            || ctx.diagnostic(HtmlHasLangDiagnostic::MissingLangProp(identifier.span)),
+            || ctx.diagnostic(missing_lang_prop(identifier.span)),
             |lang_prop| {
                 if !is_valid_lang_prop(lang_prop) {
-                    ctx.diagnostic(HtmlHasLangDiagnostic::MissingLangValue(jsx_el.span));
+                    ctx.diagnostic(missing_lang_value(jsx_el.span));
                 }
             },
         );
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/iframe_has_title.rs b/crates/oxc_linter/src/rules/jsx_a11y/iframe_has_title.rs
index 9a8cb56af516..b0691bd90ad8 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/iframe_has_title.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/iframe_has_title.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{JSXAttributeValue, JSXElementName, JSXExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,12 +14,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jsx-a11y(iframe-has-title): Missing `title` attribute for the `iframe` element."
-)]
-#[diagnostic(severity(warning), help("Provide title property for iframe element."))]
-struct IframeHasTitleDiagnostic(#[label] pub Span);
+fn iframe_has_title_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(iframe-has-title): Missing `title` attribute for the `iframe` element.")
+        .with_help("Provide title property for iframe element.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct IframeHasTitle;
@@ -71,14 +68,16 @@ impl Rule for IframeHasTitle {
             return;
         };
 
-        let Some(name) = get_element_type(ctx, jsx_el) else { return };
+        let Some(name) = get_element_type(ctx, jsx_el) else {
+            return;
+        };
 
         if name != "iframe" {
             return;
         }
 
         let Some(alt_prop) = has_jsx_prop_lowercase(jsx_el, "title") else {
-            ctx.diagnostic(IframeHasTitleDiagnostic(iden.span));
+            ctx.diagnostic(iframe_has_title_diagnostic(iden.span));
             return;
         };
 
@@ -114,7 +113,7 @@ impl Rule for IframeHasTitle {
             _ => {}
         }
 
-        ctx.diagnostic(IframeHasTitleDiagnostic(iden.span));
+        ctx.diagnostic(iframe_has_title_diagnostic(iden.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/img_redundant_alt.rs b/crates/oxc_linter/src/rules/jsx_a11y/img_redundant_alt.rs
index 86ce0db6c9bd..bc0b90a53b23 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/img_redundant_alt.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/img_redundant_alt.rs
@@ -1,13 +1,11 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use regex::Regex;
 
 use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeName, JSXAttributeValue, JSXExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,10 +14,9 @@ use crate::utils::{
 };
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(img-redundant-alt): Redundant alt attribute.")]
-#[diagnostic(severity(warning), help("Provide no redundant alt text for image. Screen-readers already announce `img` tags as an image. You don’t need to use the words `image`, `photo,` or `picture` (or any specified custom words) in the alt prop."))]
-struct ImgRedundantAltDiagnostic(#[label] pub Span);
+fn img_redundant_alt_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(img-redundant-alt): Redundant alt attribute.").with_help("Provide no redundant alt text for image. Screen-readers already announce `img` tags as an image. You don’t need to use the words `image`, `photo,` or `picture` (or any specified custom words) in the alt prop.").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ImgRedundantAlt(Box<ImgRedundantAltConfig>);
@@ -105,7 +102,9 @@ impl Rule for ImgRedundantAlt {
         Self(Box::new(img_redundant_alt))
     }
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else {
+            return;
+        };
         let Some(element_type) = get_element_type(ctx, jsx_el) else {
             return;
         };
@@ -143,7 +142,7 @@ impl Rule for ImgRedundantAlt {
                 let alt_text = lit.value.as_str();
 
                 if is_redundant_alt_text(alt_text, &self.redundant_words) {
-                    ctx.diagnostic(ImgRedundantAltDiagnostic(alt_attribute_name_span));
+                    ctx.diagnostic(img_redundant_alt_diagnostic(alt_attribute_name_span));
                 }
             }
             JSXAttributeValue::ExpressionContainer(container) => match &container.expression {
@@ -151,7 +150,7 @@ impl Rule for ImgRedundantAlt {
                     let alt_text = lit.value.as_str();
 
                     if is_redundant_alt_text(alt_text, &self.redundant_words) {
-                        ctx.diagnostic(ImgRedundantAltDiagnostic(alt_attribute_name_span));
+                        ctx.diagnostic(img_redundant_alt_diagnostic(alt_attribute_name_span));
                     }
                 }
                 JSXExpression::TemplateLiteral(lit) => {
@@ -159,7 +158,7 @@ impl Rule for ImgRedundantAlt {
                         let alt_text = quasi.value.raw.as_str();
 
                         if is_redundant_alt_text(alt_text, &self.redundant_words) {
-                            ctx.diagnostic(ImgRedundantAltDiagnostic(alt_attribute_name_span));
+                            ctx.diagnostic(img_redundant_alt_diagnostic(alt_attribute_name_span));
                         }
                     }
                 }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/lang.rs b/crates/oxc_linter/src/rules/jsx_a11y/lang.rs
index bb1271b34743..6f9ffad7e2f3 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/lang.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/lang.rs
@@ -3,10 +3,8 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeValue, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -17,10 +15,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(lang): Lang attribute must have a valid value.")]
-#[diagnostic(severity(warning), help("Set a valid value for lang attribute."))]
-struct LangDiagnostic(#[label] pub Span);
+fn lang_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(lang): Lang attribute must have a valid value.")
+        .with_help("Set a valid value for lang attribute.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct Lang;
@@ -78,11 +77,11 @@ impl Rule for Lang {
         };
 
         has_jsx_prop_lowercase(jsx_el, "lang").map_or_else(
-            || ctx.diagnostic(LangDiagnostic(identifier.span)),
+            || ctx.diagnostic(lang_diagnostic(identifier.span)),
             |lang_prop| {
                 if !is_valid_lang_prop(lang_prop) {
                     if let JSXAttributeItem::Attribute(attr) = lang_prop {
-                        ctx.diagnostic(LangDiagnostic(attr.span));
+                        ctx.diagnostic(lang_diagnostic(attr.span));
                     }
                 }
             },
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/media_has_caption.rs b/crates/oxc_linter/src/rules/jsx_a11y/media_has_caption.rs
index 0af2afa97300..902e95b7d99a 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/media_has_caption.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/media_has_caption.rs
@@ -2,22 +2,18 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeName, JSXAttributeValue, JSXChild, JSXExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, utils::get_element_type, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(media-has-caption): Missing <track> element with captions inside <audio> or <video> element")]
-#[diagnostic(
-    severity(warning),
-    help("Media elements such as <audio> and <video> must have a <track> for captions.")
-)]
-struct MediaHasCaptionDiagnostic(#[label] pub Span);
+fn media_has_caption_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(media-has-caption): Missing <track> element with captions inside <audio> or <video> element")
+        .with_help("Media elements such as <audio> and <video> must have a <track> for captions.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct MediaHasCaption(Box<MediaHasCaptionConfig>);
@@ -92,7 +88,9 @@ impl Rule for MediaHasCaption {
         Self(Box::new(config))
     }
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else {
+            return;
+        };
 
         let Some(element_name) = get_element_type(ctx, jsx_el) else {
             return;
@@ -137,7 +135,7 @@ impl Rule for MediaHasCaption {
         };
 
         let has_caption = if parent.children.is_empty() {
-            ctx.diagnostic(MediaHasCaptionDiagnostic(parent.opening_element.span));
+            ctx.diagnostic(media_has_caption_diagnostic(parent.opening_element.span));
             false
         } else {
             parent.children.iter().any(|child| match child {
@@ -165,7 +163,7 @@ impl Rule for MediaHasCaption {
         let span = parent.span;
 
         if !has_caption {
-            ctx.diagnostic(MediaHasCaptionDiagnostic(span));
+            ctx.diagnostic(media_has_caption_diagnostic(span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/mouse_events_have_key_events.rs b/crates/oxc_linter/src/rules/jsx_a11y/mouse_events_have_key_events.rs
index 00f6aa90e902..92ecde9b269f 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/mouse_events_have_key_events.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/mouse_events_have_key_events.rs
@@ -1,8 +1,5 @@
 use oxc_ast::{ast::JSXAttributeValue, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -14,15 +11,16 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum MouseEventsHaveKeyEventsDiagnostic {
-    #[error("eslint-plugin-jsx-a11y(mouse-events-have-key-events): {1} must be accompanied by onFocus for accessibility.")]
-    #[diagnostic(severity(warning), help("Try to add onFocus."))]
-    MissOnFocus(#[label] Span, String),
+fn miss_on_focus(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jsx-a11y(mouse-events-have-key-events): {x1} must be accompanied by onFocus for accessibility."))
+        .with_help("Try to add onFocus.")
+        .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-jsx-a11y(mouse-events-have-key-events): {1} must be accompanied by onBlur for accessibility.")]
-    #[diagnostic(severity(warning), help("Try to add onBlur."))]
-    MissOnBlur(#[label] Span, String),
+fn miss_on_blur(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jsx-a11y(mouse-events-have-key-events): {x1} must be accompanied by onBlur for accessibility."))
+        .with_help("Try to add onBlur.")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -119,18 +117,12 @@ impl Rule for MouseEventsHaveKeyEvents {
                     Some(JSXAttributeValue::ExpressionContainer(container)) => {
                         if let Some(expr) = container.expression.as_expression() {
                             if expr.is_undefined() {
-                                ctx.diagnostic(MouseEventsHaveKeyEventsDiagnostic::MissOnFocus(
-                                    jsx_attr.span(),
-                                    String::from(handler),
-                                ));
+                                ctx.diagnostic(miss_on_focus(jsx_attr.span(), handler));
                             }
                         }
                     }
                     None => {
-                        ctx.diagnostic(MouseEventsHaveKeyEventsDiagnostic::MissOnFocus(
-                            jsx_attr.span(),
-                            String::from(handler),
-                        ));
+                        ctx.diagnostic(miss_on_focus(jsx_attr.span(), handler));
                     }
                     _ => {}
                 }
@@ -148,17 +140,11 @@ impl Rule for MouseEventsHaveKeyEvents {
                 match has_jsx_prop(jsx_opening_el, "onBlur").and_then(get_prop_value) {
                     Some(JSXAttributeValue::ExpressionContainer(container)) => {
                         if container.expression.is_undefined() {
-                            ctx.diagnostic(MouseEventsHaveKeyEventsDiagnostic::MissOnBlur(
-                                jsx_attr.span(),
-                                String::from(handler),
-                            ));
+                            ctx.diagnostic(miss_on_blur(jsx_attr.span(), handler));
                         }
                     }
                     None => {
-                        ctx.diagnostic(MouseEventsHaveKeyEventsDiagnostic::MissOnBlur(
-                            jsx_attr.span(),
-                            String::from(handler),
-                        ));
+                        ctx.diagnostic(miss_on_blur(jsx_attr.span(), handler));
                     }
                     _ => {}
                 }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/no_access_key.rs b/crates/oxc_linter/src/rules/jsx_a11y/no_access_key.rs
index ae7811b78231..465cdd15cf8a 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/no_access_key.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/no_access_key.rs
@@ -2,19 +2,18 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeValue},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, utils::has_jsx_prop_lowercase, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(no-access-key): No access key attribute allowed.")]
-#[diagnostic(severity(warning), help("Remove the accessKey attribute. Inconsistencies between keyboard shortcuts and keyboard commands used by screenreaders and keyboard-only users create a11y complications."))]
-struct NoAccessKeyDiagnostic(#[label] pub Span);
+fn no_access_key_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(no-access-key): No access key attribute allowed.")
+        .with_help("Remove the accessKey attribute. Inconsistencies between keyboard shortcuts and keyboard commands used by screenreaders and keyboard-only users create a11y complications.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAccessKey;
@@ -41,17 +40,19 @@ declare_oxc_lint!(
 
 impl Rule for NoAccessKey {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else {
+            return;
+        };
         if let Some(JSXAttributeItem::Attribute(attr)) = has_jsx_prop_lowercase(jsx_el, "accessKey")
         {
             match attr.value.as_ref() {
                 Some(JSXAttributeValue::StringLiteral(_)) => {
-                    ctx.diagnostic(NoAccessKeyDiagnostic(attr.span));
+                    ctx.diagnostic(no_access_key_diagnostic(attr.span));
                 }
                 Some(JSXAttributeValue::ExpressionContainer(container)) => {
                     if container.expression.is_expression() && !container.expression.is_undefined()
                     {
-                        ctx.diagnostic(NoAccessKeyDiagnostic(attr.span));
+                        ctx.diagnostic(no_access_key_diagnostic(attr.span));
                     }
                 }
                 _ => {}
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/no_aria_hidden_on_focusable.rs b/crates/oxc_linter/src/rules/jsx_a11y/no_aria_hidden_on_focusable.rs
index 6868664bdd22..04d0a399ed41 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/no_aria_hidden_on_focusable.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/no_aria_hidden_on_focusable.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeValue, JSXOpeningElement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,10 +14,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(no-aria-hidden-on-focusable): `aria-hidden` must not be true on focusable elements.")]
-#[diagnostic(severity(warning), help("Remove `aria-hidden=\"true\"` from focusable elements or modify the element to be not focusable."))]
-struct NoAriaHiddenOnFocusableDiagnostic(#[label] pub Span);
+fn no_aria_hidden_on_focusable_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(no-aria-hidden-on-focusable): `aria-hidden` must not be true on focusable elements.")
+        .with_help("Remove `aria-hidden=\"true\"` from focusable elements or modify the element to be not focusable.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAriaHiddenOnFocusable;
@@ -45,11 +44,13 @@ declare_oxc_lint!(
 
 impl Rule for NoAriaHiddenOnFocusable {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else {
+            return;
+        };
         if let Some(aria_hidden_prop) = has_jsx_prop_lowercase(jsx_el, "aria-hidden") {
             if is_aria_hidden_true(aria_hidden_prop) && is_focusable(ctx, jsx_el) {
                 if let JSXAttributeItem::Attribute(boxed_attr) = aria_hidden_prop {
-                    ctx.diagnostic(NoAriaHiddenOnFocusableDiagnostic(boxed_attr.span));
+                    ctx.diagnostic(no_aria_hidden_on_focusable_diagnostic(boxed_attr.span));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/no_autofocus.rs b/crates/oxc_linter/src/rules/jsx_a11y/no_autofocus.rs
index efab7c89f4ec..74a4eb0295b6 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/no_autofocus.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/no_autofocus.rs
@@ -1,8 +1,6 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -14,10 +12,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(no-autofocus): The `autofocus` attribute is found here, which can cause usability issues for sighted and non-sighted users")]
-#[diagnostic(severity(warning), help("Remove `autofocus` attribute"))]
-struct NoAutofocusDiagnostic(#[label] pub Span);
+fn no_autofocus_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(no-autofocus): The `autofocus` attribute is found here, which can cause usability issues for sighted and non-sighted users")
+        .with_help("Remove `autofocus` attribute")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAutofocus {
@@ -98,14 +97,14 @@ impl Rule for NoAutofocus {
                 if self.ignore_non_dom {
                     if HTML_TAG.contains(&element_type) {
                         if let oxc_ast::ast::JSXAttributeItem::Attribute(attr) = autofocus {
-                            ctx.diagnostic(NoAutofocusDiagnostic(attr.span));
+                            ctx.diagnostic(no_autofocus_diagnostic(attr.span));
                         }
                     }
                     return;
                 }
 
                 if let oxc_ast::ast::JSXAttributeItem::Attribute(attr) = autofocus {
-                    ctx.diagnostic(NoAutofocusDiagnostic(attr.span));
+                    ctx.diagnostic(no_autofocus_diagnostic(attr.span));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/no_distracting_elements.rs b/crates/oxc_linter/src/rules/jsx_a11y/no_distracting_elements.rs
index 63ff8b46f49f..e73830302ac0 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/no_distracting_elements.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/no_distracting_elements.rs
@@ -1,19 +1,17 @@
 use oxc_ast::{ast::JSXElementName, AstKind};
-use oxc_diagnostics::thiserror::Error;
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNode;
 use oxc_span::Span;
 
-use oxc_diagnostics::miette::{self, Diagnostic};
-
 use crate::{rule::Rule, utils::get_element_type, LintContext};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jsx-a11y(no-distracting-elements): Do not use <marquee> or <blink> elements as they can create visual accessibility issues and are deprecated."
-)]
-#[diagnostic(severity(warning), help("Replace the <marquee> or <blink> element with alternative, more accessible ways to achieve your desired visual effects."))]
-struct NoDistractingElementsDiagnostic(#[label] pub Span);
+fn no_distracting_elements_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-jsx-a11y(no-distracting-elements): Do not use <marquee> or <blink> elements as they can create visual accessibility issues and are deprecated.")
+        .with_help("Replace the <marquee> or <blink> element with alternative, more accessible ways to achieve your desired visual effects.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDistractingElements;
@@ -53,8 +51,12 @@ declare_oxc_lint!(
 
 impl Rule for NoDistractingElements {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else { return };
-        let JSXElementName::Identifier(iden) = &jsx_el.name else { return };
+        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else {
+            return;
+        };
+        let JSXElementName::Identifier(iden) = &jsx_el.name else {
+            return;
+        };
         let Some(element_type) = get_element_type(ctx, jsx_el) else {
             return;
         };
@@ -62,7 +64,7 @@ impl Rule for NoDistractingElements {
         let name = element_type.as_str();
 
         if let "marquee" | "blink" = name {
-            ctx.diagnostic(NoDistractingElementsDiagnostic(iden.span));
+            ctx.diagnostic(no_distracting_elements_diagnostic(iden.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/no_redundant_roles.rs b/crates/oxc_linter/src/rules/jsx_a11y/no_redundant_roles.rs
index 3ce65602e8bc..9de315a1e419 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/no_redundant_roles.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/no_redundant_roles.rs
@@ -8,27 +8,18 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeValue},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::phf_map;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jsx-a11y(no-redundant-roles): The element `{element}` has an implicit role of `{role}`. Defining this explicitly is redundant and should be avoided."
-)]
-#[diagnostic(
-    severity(warning),
-    help("Remove the redundant role `{role}` from the element `{element}`.")
-)]
-struct NoRedundantRolesDiagnostic {
-    #[label]
-    pub span: Span,
-    pub element: String,
-    pub role: String,
+fn no_redundant_roles_diagnostic(span: Span, element: &str, role: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-jsx-a11y(no-redundant-roles): The element `{element}` has an implicit role of `{role}`. Defining this explicitly is redundant and should be avoided."
+    ))
+    .with_help(format!("Remove the redundant role `{role}` from the element `{element}`."))
+    .with_label(span)
 }
 
 #[derive(Debug, Default, Clone)]
@@ -75,11 +66,9 @@ impl Rule for NoRedundantRoles {
                         for role in &roles {
                             let exceptions = DEFAULT_ROLE_EXCEPTIONS.get(&component);
                             if exceptions.map_or(false, |set| set.contains(role)) {
-                                ctx.diagnostic(NoRedundantRolesDiagnostic {
-                                    span: attr.span,
-                                    element: component.clone(),
-                                    role: role.to_string(),
-                                });
+                                ctx.diagnostic(no_redundant_roles_diagnostic(
+                                    attr.span, &component, role,
+                                ));
                             }
                         }
                     }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/prefer_tag_over_role.rs b/crates/oxc_linter/src/rules/jsx_a11y/prefer_tag_over_role.rs
index 25e266eccffd..b01dd73d44da 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/prefer_tag_over_role.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/prefer_tag_over_role.rs
@@ -9,28 +9,18 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeValue},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::phf_map;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jsx-a11y(prefer-tag-over-role): Prefer `{tag}` over `role` attribute `{role}`."
-)]
-#[diagnostic(
-    severity(warning),
-    help("Replace HTML elements with `role` attribute `{role}` to corresponding semantic HTML tag `{tag}`.")
-)]
-struct PreferTagOverRoleDiagnostic {
-    #[label]
-    pub span: Span,
-    pub tag: String,
-    pub role: String,
+fn prefer_tag_over_role_diagnostic(span: Span, tag: &str, role: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jsx-a11y(prefer-tag-over-role): Prefer `{tag}` over `role` attribute `{role}`."))
+        .with_help(format!("Replace HTML elements with `role` attribute `{role}` to corresponding semantic HTML tag `{tag}`."))
+        .with_label(span)
 }
+
 #[derive(Debug, Default, Clone)]
 pub struct PreferTagOverRole;
 
@@ -79,11 +69,7 @@ impl PreferTagOverRole {
     ) {
         if let Some(tag) = role_to_tag.get(role) {
             if jsx_name != *tag {
-                ctx.diagnostic(PreferTagOverRoleDiagnostic {
-                    span,
-                    tag: (*tag).to_string(),
-                    role: role.to_string(),
-                });
+                ctx.diagnostic(prefer_tag_over_role_diagnostic(span, tag, role));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/role_has_required_aria_props.rs b/crates/oxc_linter/src/rules/jsx_a11y/role_has_required_aria_props.rs
index dee0eea36a3a..43e5c1ebeb08 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/role_has_required_aria_props.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/role_has_required_aria_props.rs
@@ -3,27 +3,16 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeValue},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::{phf_map, phf_set};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jsx-a11y(role-has-required-aria-props): `{role}` role is missing required aria props `{props}`."
-)]
-#[diagnostic(
-    severity(warning),
-    help("Add missing aria props `{props}` to the element with `{role}` role.")
-)]
-struct RoleHasRequiredAriaPropsDiagnostic {
-    #[label]
-    pub span: Span,
-    pub role: String,
-    pub props: String,
+fn role_has_required_aria_props_diagnostic(span: Span, role: &str, props: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jsx-a11y(role-has-required-aria-props): `{role}` role is missing required aria props `{props}`."))
+        .with_help(format!("Add missing aria props `{props}` to the element with `{role}` role."))
+        .and_label(span)
 }
 
 #[derive(Debug, Default, Clone)]
@@ -61,19 +50,23 @@ static ROLE_TO_REQUIRED_ARIA_PROPS: phf::Map<&'static str, phf::Set<&'static str
 impl Rule for RoleHasRequiredAriaProps {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::JSXOpeningElement(jsx_el) = node.kind() {
-            let Some(role_prop) = has_jsx_prop_lowercase(jsx_el, "role") else { return };
-            let JSXAttributeItem::Attribute(attr) = role_prop else { return };
-            let Some(JSXAttributeValue::StringLiteral(role_values)) = &attr.value else { return };
+            let Some(role_prop) = has_jsx_prop_lowercase(jsx_el, "role") else {
+                return;
+            };
+            let JSXAttributeItem::Attribute(attr) = role_prop else {
+                return;
+            };
+            let Some(JSXAttributeValue::StringLiteral(role_values)) = &attr.value else {
+                return;
+            };
             let roles = role_values.value.split_whitespace();
             for role in roles {
                 if let Some(props) = ROLE_TO_REQUIRED_ARIA_PROPS.get(role) {
                     for prop in props {
                         if has_jsx_prop_lowercase(jsx_el, prop).is_none() {
-                            ctx.diagnostic(RoleHasRequiredAriaPropsDiagnostic {
-                                span: attr.span,
-                                role: role.into(),
-                                props: (*prop).into(),
-                            });
+                            ctx.diagnostic(role_has_required_aria_props_diagnostic(
+                                attr.span, role, prop,
+                            ));
                         }
                     }
                 }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/role_supports_aria_props.rs b/crates/oxc_linter/src/rules/jsx_a11y/role_supports_aria_props.rs
index b283a99a4270..5ba9166d205a 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/role_supports_aria_props.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/role_supports_aria_props.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXOpeningElement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::phf_set;
@@ -50,15 +48,16 @@ declare_oxc_lint!(
 #[derive(Debug, Default, Clone)]
 pub struct RoleSupportsAriaProps;
 
-#[derive(Debug, Error, Diagnostic)]
-enum RoleSupportsAriaPropsDiagnostic {
-    #[error("eslint-plugin-jsx-a11y(role-supports-aria-props): The attribute {1} is not supported by the role {2}.")]
-    #[diagnostic(severity(warning), help("Try to remove invalid attribute {1}."))]
-    Default(#[label] Span, String, String),
+fn default(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jsx-a11y(role-supports-aria-props): The attribute {x1} is not supported by the role {x2}."))
+        .with_help(format!("Try to remove invalid attribute {x1}."))
+        .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-jsx-a11y(role-supports-aria-props): The attribute {1} is not supported by the role {2}. This role is implicit on the element {3}.")]
-    #[diagnostic(severity(warning), help("Try to remove invalid attribute {1}."))]
-    IsImplicit(#[label] Span, String, String, String),
+fn is_implicit_diagnostic(span0: Span, x1: &str, x2: &str, x3: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-jsx-a11y(role-supports-aria-props): The attribute {x1} is not supported by the role {x2}. This role is implicit on the element {x3}."))
+        .with_help(format!("Try to remove invalid attribute {x1}."))
+        .with_labels([span0.into()])
 }
 
 impl Rule for RoleSupportsAriaProps {
@@ -81,18 +80,9 @@ impl Rule for RoleSupportsAriaProps {
                             let name = get_jsx_attribute_name(&attr.name).to_lowercase();
                             if invalid_props.contains(&&name.as_str()) {
                                 ctx.diagnostic(if is_implicit {
-                                    RoleSupportsAriaPropsDiagnostic::IsImplicit(
-                                        attr.span,
-                                        name,
-                                        role_value.to_string(),
-                                        el_type.clone(),
-                                    )
+                                    is_implicit_diagnostic(attr.span, &name, role_value, &el_type)
                                 } else {
-                                    RoleSupportsAriaPropsDiagnostic::Default(
-                                        attr.span,
-                                        name,
-                                        role_value.to_string(),
-                                    )
+                                    default(attr.span, &name, role_value)
                                 });
                             }
                         }
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/scope.rs b/crates/oxc_linter/src/rules/jsx_a11y/scope.rs
index 59f07a24f7d1..f1545b72c522 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/scope.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/scope.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::JSXAttributeItem, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -14,10 +12,13 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-jsx-a11y(scope): The scope prop can only be used on <th> elements")]
-#[diagnostic(severity(warning), help("Must use scope prop only on <th> elements"))]
-struct ScopeDiagnostic(#[label] pub Span);
+fn scope_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsx-a11y(scope): The scope prop can only be used on <th> elements",
+    )
+    .with_help("Must use scope prop only on <th> elements")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct Scope;
@@ -75,7 +76,7 @@ impl Rule for Scope {
             return;
         }
 
-        ctx.diagnostic(ScopeDiagnostic(scope_attribute.span));
+        ctx.diagnostic(scope_diagnostic(scope_attribute.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/jsx_a11y/tabindex_no_positive.rs b/crates/oxc_linter/src/rules/jsx_a11y/tabindex_no_positive.rs
index ff6eca72f30d..9723fb0773a2 100644
--- a/crates/oxc_linter/src/rules/jsx_a11y/tabindex_no_positive.rs
+++ b/crates/oxc_linter/src/rules/jsx_a11y/tabindex_no_positive.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::JSXAttributeItem, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -13,12 +11,13 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-jsx-a11y(tabindex-no-positive): Avoid positive integer values for tabIndex."
-)]
-#[diagnostic(severity(warning), help("Change the tabIndex prop to a non-negative value"))]
-struct TabindexNoPositiveDiagnostic(#[label] pub Span);
+fn tabindex_no_positive_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-jsx-a11y(tabindex-no-positive): Avoid positive integer values for tabIndex.",
+    )
+    .with_help("Change the tabIndex prop to a non-negative value")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct TabindexNoPositive;
@@ -45,7 +44,9 @@ declare_oxc_lint!(
 
 impl Rule for TabindexNoPositive {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_el) = node.kind() else {
+            return;
+        };
         if let Some(tab_index_prop) = has_jsx_prop_lowercase(jsx_el, "tabIndex") {
             check_and_diagnose(tab_index_prop, ctx);
         }
@@ -57,7 +58,7 @@ fn check_and_diagnose(attr: &JSXAttributeItem, ctx: &LintContext<'_>) {
         JSXAttributeItem::Attribute(attr) => attr.value.as_ref().map_or((), |value| {
             if let Ok(parsed_value) = parse_jsx_value(value) {
                 if parsed_value > 0.0 {
-                    ctx.diagnostic(TabindexNoPositiveDiagnostic(attr.span));
+                    ctx.diagnostic(tabindex_no_positive_diagnostic(attr.span));
                 }
             }
         }),
diff --git a/crates/oxc_linter/src/rules/nextjs/google_font_display.rs b/crates/oxc_linter/src/rules/nextjs/google_font_display.rs
index 44c6849fe630..04a6d5bff10b 100644
--- a/crates/oxc_linter/src/rules/nextjs/google_font_display.rs
+++ b/crates/oxc_linter/src/rules/nextjs/google_font_display.rs
@@ -1,8 +1,5 @@
 use oxc_ast::{ast::JSXElementName, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -13,23 +10,18 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum GoogleFontDisplayDiagnostic {
-    #[error("eslint-plugin-next(google-font-display): A font-display parameter is missing (adding `&display=optional` is recommended).")]
-    #[diagnostic(
-        severity(warning),
-        help("See https://nextjs.org/docs/messages/google-font-display")
-    )]
-    FontDisplayParameterMissing(#[label] Span),
-
-    #[error(
-        "eslint-plugin-next(google-font-display): `{1}` is not a recommended font-display value."
-    )]
-    #[diagnostic(
-        severity(warning),
-        help("See https://nextjs.org/docs/messages/google-font-display")
-    )]
-    NotRecommendedFontDisplayValue(#[label] Span, String),
+fn font_display_parameter_missing(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(google-font-display): A font-display parameter is missing (adding `&display=optional` is recommended).")
+        .with_help("See https://nextjs.org/docs/messages/google-font-display")
+        .with_labels([span0.into()])
+}
+
+fn not_recommended_font_display_value(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-next(google-font-display): `{x1}` is not a recommended font-display value."
+    ))
+    .with_help("See https://nextjs.org/docs/messages/google-font-display")
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -51,7 +43,9 @@ declare_oxc_lint!(
 
 impl Rule for GoogleFontDisplay {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else {
+            return;
+        };
 
         let JSXElementName::Identifier(jsx_opening_element_name) = &jsx_opening_element.name else {
             return;
@@ -65,23 +59,25 @@ impl Rule for GoogleFontDisplay {
             return;
         };
 
-        let Some(href_prop_value) = get_string_literal_prop_value(href_prop) else { return };
+        let Some(href_prop_value) = get_string_literal_prop_value(href_prop) else {
+            return;
+        };
 
         if href_prop_value.starts_with("https://fonts.googleapis.com/css") {
-            let Ok(url) = url::Url::parse(href_prop_value) else { return };
+            let Ok(url) = url::Url::parse(href_prop_value) else {
+                return;
+            };
 
             let Some((_, display_value)) = url.query_pairs().find(|(key, _)| key == "display")
             else {
-                ctx.diagnostic(GoogleFontDisplayDiagnostic::FontDisplayParameterMissing(
-                    jsx_opening_element_name.span,
-                ));
+                ctx.diagnostic(font_display_parameter_missing(jsx_opening_element_name.span));
                 return;
             };
 
             if matches!(&*display_value, "auto" | "block" | "fallback") {
-                ctx.diagnostic(GoogleFontDisplayDiagnostic::NotRecommendedFontDisplayValue(
+                ctx.diagnostic(not_recommended_font_display_value(
                     href_prop.span(),
-                    display_value.to_string(),
+                    &display_value,
                 ));
             }
         }
@@ -94,7 +90,7 @@ fn test() {
 
     let pass = vec![
         r#"import Head from "next/head";
-			
+
 			     export default Test = () => {
 			      return (
 			        <Head>
@@ -116,7 +112,7 @@ fn test() {
 			     };
 			    "#,
         r#"import Document, { Html, Head } from "next/document";
-			
+
 			     class MyDocument extends Document {
 			      render() {
 			        return (
@@ -131,11 +127,11 @@ fn test() {
 			        );
 			      }
 			     }
-			
+
 			     export default MyDocument;
 			    "#,
         r#"import Document, { Html, Head } from "next/document";
-			
+
 			     class MyDocument extends Document {
 			      render() {
 			        return (
@@ -151,14 +147,14 @@ fn test() {
 			        );
 			      }
 			     }
-			
+
 			     export default MyDocument;
 			    "#,
     ];
 
     let fail = vec![
         r#"import Head from "next/head";
-			
+
 			      export default Test = () => {
 			       return (
 			         <Head>
@@ -171,7 +167,7 @@ fn test() {
 			      };
 			     "#,
         r#"import Head from "next/head";
-			
+
 			      export default Test = () => {
 			       return (
 			         <Head>
@@ -184,7 +180,7 @@ fn test() {
 			      };
 			     "#,
         r#"import Head from "next/head";
-			
+
 			      export default Test = () => {
 			       return (
 			         <Head>
@@ -197,7 +193,7 @@ fn test() {
 			      };
 			     "#,
         r#"import Head from "next/head";
-			
+
 			      export default Test = () => {
 			       return (
 			         <Head>
diff --git a/crates/oxc_linter/src/rules/nextjs/google_font_preconnect.rs b/crates/oxc_linter/src/rules/nextjs/google_font_preconnect.rs
index 076e4d79fe63..100dc195a01c 100644
--- a/crates/oxc_linter/src/rules/nextjs/google_font_preconnect.rs
+++ b/crates/oxc_linter/src/rules/nextjs/google_font_preconnect.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::JSXElementName, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -13,13 +11,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(r#"eslint-plugin-next(google-font-preconnect): `rel="preconnect"` is missing from Google Font."#)]
-#[diagnostic(
-    severity(warning),
-    help("See: https://nextjs.org/docs/messages/google-font-preconnect")
-)]
-struct GoogleFontPreconnectDiagnostic(#[label] pub Span);
+fn google_font_preconnect_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(r#"eslint-plugin-next(google-font-preconnect): `rel="preconnect"` is missing from Google Font."#)
+        .with_help("See: https://nextjs.org/docs/messages/google-font-preconnect")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct GoogleFontPreconnect;
@@ -40,7 +36,9 @@ declare_oxc_lint!(
 
 impl Rule for GoogleFontPreconnect {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else {
+            return;
+        };
 
         let JSXElementName::Identifier(jsx_opening_element_name) = &jsx_opening_element.name else {
             return;
@@ -53,7 +51,9 @@ impl Rule for GoogleFontPreconnect {
         let Some(href_prop) = has_jsx_prop_lowercase(jsx_opening_element, "href") else {
             return;
         };
-        let Some(href_prop_value) = get_string_literal_prop_value(href_prop) else { return };
+        let Some(href_prop_value) = get_string_literal_prop_value(href_prop) else {
+            return;
+        };
 
         let preconnect_missing =
             has_jsx_prop_lowercase(jsx_opening_element, "rel").map_or(true, |rel_prop| {
@@ -62,7 +62,7 @@ impl Rule for GoogleFontPreconnect {
             });
 
         if href_prop_value.starts_with("https://fonts.gstatic.com") && preconnect_missing {
-            ctx.diagnostic(GoogleFontPreconnectDiagnostic(jsx_opening_element_name.span));
+            ctx.diagnostic(google_font_preconnect_diagnostic(jsx_opening_element_name.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/nextjs/inline_script_id.rs b/crates/oxc_linter/src/rules/nextjs/inline_script_id.rs
index 267b958abcf3..723588628719 100644
--- a/crates/oxc_linter/src/rules/nextjs/inline_script_id.rs
+++ b/crates/oxc_linter/src/rules/nextjs/inline_script_id.rs
@@ -2,20 +2,19 @@ use oxc_ast::{
     ast::{Expression, JSXAttributeItem, JSXAttributeName, ObjectPropertyKind, PropertyKey},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use rustc_hash::FxHashSet;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(inline-script-id): `next/script` components with inline content must specify an `id` attribute.")]
-#[diagnostic(severity(warning), help("See https://nextjs.org/docs/messages/inline-script-id"))]
-struct InlineScriptIdDiagnostic(#[label] pub Span);
+fn inline_script_id_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(inline-script-id): `next/script` components with inline content must specify an `id` attribute.")
+        .with_help("See https://nextjs.org/docs/messages/inline-script-id")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct InlineScriptId;
@@ -51,9 +50,13 @@ impl Rule for InlineScriptId {
         'references_loop: for reference in
             ctx.semantic().symbol_references(specifier.local.symbol_id.get().unwrap())
         {
-            let Some(node) = ctx.nodes().parent_node(reference.node_id()) else { return };
+            let Some(node) = ctx.nodes().parent_node(reference.node_id()) else {
+                return;
+            };
 
-            let AstKind::JSXElementName(_) = node.kind() else { continue };
+            let AstKind::JSXElementName(_) = node.kind() else {
+                continue;
+            };
             let parent_node = ctx.nodes().parent_node(node.id()).unwrap();
             let AstKind::JSXOpeningElement(jsx_opening_element) = parent_node.kind() else {
                 continue;
@@ -98,7 +101,7 @@ impl Rule for InlineScriptId {
             if jsx_element.children.len() > 0
                 || prop_names_hash_set.contains("dangerouslySetInnerHTML")
             {
-                ctx.diagnostic(InlineScriptIdDiagnostic(jsx_opening_element.name.span()));
+                ctx.diagnostic(inline_script_id_diagnostic(jsx_opening_element.name.span()));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/nextjs/next_script_for_ga.rs b/crates/oxc_linter/src/rules/nextjs/next_script_for_ga.rs
index b7faf9f74754..4b61b72091cf 100644
--- a/crates/oxc_linter/src/rules/nextjs/next_script_for_ga.rs
+++ b/crates/oxc_linter/src/rules/nextjs/next_script_for_ga.rs
@@ -5,10 +5,8 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -19,10 +17,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(next-script-for-ga): Prefer `next/script` component when using the inline script for Google Analytics.")]
-#[diagnostic(severity(warning), help("See https://nextjs.org/docs/messages/next-script-for-ga"))]
-struct NextScriptForGaDiagnostic(#[label] pub Span);
+fn next_script_for_ga_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(next-script-for-ga): Prefer `next/script` component when using the inline script for Google Analytics.")
+        .with_help("See https://nextjs.org/docs/messages/next-script-for-ga")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NextScriptForGa;
@@ -43,7 +42,9 @@ declare_oxc_lint!(
 
 impl Rule for NextScriptForGa {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else {
+            return;
+        };
 
         let JSXElementName::Identifier(jsx_opening_element_name) = &jsx_opening_element.name else {
             return;
@@ -59,7 +60,7 @@ impl Rule for NextScriptForGa {
         if let Some(src_prop) = has_jsx_prop_lowercase(jsx_opening_element, "src") {
             if let Some(src_prop_value) = get_string_literal_prop_value(src_prop) {
                 if SUPPORTED_SRCS.iter().any(|s| src_prop_value.contains(s)) {
-                    ctx.diagnostic(NextScriptForGaDiagnostic(jsx_opening_element_name.span));
+                    ctx.diagnostic(next_script_for_ga_diagnostic(jsx_opening_element_name.span));
                     return;
                 }
             }
@@ -69,10 +70,12 @@ impl Rule for NextScriptForGa {
         // https://developers.google.com/analytics/devguides/collection/analyticsjs#the_google_analytics_tag
         // https://developers.google.com/tag-manager/quickstart
         if let Some(danger_value) = get_dangerously_set_inner_html_prop_value(jsx_opening_element) {
-            let Expression::TemplateLiteral(template_literal) = &danger_value.value else { return };
+            let Expression::TemplateLiteral(template_literal) = &danger_value.value else {
+                return;
+            };
             let template_literal = template_literal.quasis[0].value.raw.as_str();
             if SUPPORTED_HTML_CONTENT_URLS.iter().any(|s| template_literal.contains(s)) {
-                ctx.diagnostic(NextScriptForGaDiagnostic(jsx_opening_element_name.span));
+                ctx.diagnostic(next_script_for_ga_diagnostic(jsx_opening_element_name.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_assign_module_variable.rs b/crates/oxc_linter/src/rules/nextjs/no_assign_module_variable.rs
index af8754c4a329..fa292a6e0a8e 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_assign_module_variable.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_assign_module_variable.rs
@@ -1,20 +1,18 @@
 use oxc_ast::{ast::BindingPatternKind, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-assign-module-variable): Do not assign to the variable `module`.")]
-#[diagnostic(
-    severity(warning),
-    help("See https://nextjs.org/docs/messages/no-assign-module-variable")
-)]
-struct NoAssignModuleVariableDiagnostic(#[label] pub Span);
+fn no_assign_module_variable_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-next(no-assign-module-variable): Do not assign to the variable `module`.",
+    )
+    .with_help("See https://nextjs.org/docs/messages/no-assign-module-variable")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAssignModuleVariable;
@@ -35,7 +33,9 @@ declare_oxc_lint!(
 
 impl Rule for NoAssignModuleVariable {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::VariableDeclaration(variable_decl) = node.kind() else { return };
+        let AstKind::VariableDeclaration(variable_decl) = node.kind() else {
+            return;
+        };
 
         for decl in &variable_decl.declarations {
             let BindingPatternKind::BindingIdentifier(binding_ident) = &decl.id.kind else {
@@ -43,7 +43,7 @@ impl Rule for NoAssignModuleVariable {
             };
 
             if binding_ident.name == "module" {
-                ctx.diagnostic(NoAssignModuleVariableDiagnostic(binding_ident.span));
+                ctx.diagnostic(no_assign_module_variable_diagnostic(binding_ident.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_async_client_component.rs b/crates/oxc_linter/src/rules/nextjs/no_async_client_component.rs
index 36ec34564eb5..b01533a99d5a 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_async_client_component.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_async_client_component.rs
@@ -2,22 +2,18 @@ use oxc_ast::{
     ast::{BindingPatternKind, ExportDefaultDeclarationKind, Expression, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{ast_util::get_declaration_of_variable, context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-async-client-component): Prevent client components from being async functions.")]
-#[diagnostic(
-    severity(warning),
-    help("See: https://nextjs.org/docs/messages/no-async-client-component")
-)]
-struct NoAsyncClientComponentDiagnostic(#[label] pub Span);
+fn no_async_client_component_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-async-client-component): Prevent client components from being async functions.")
+        .with_help("See: https://nextjs.org/docs/messages/no-async-client-component")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAsyncClientComponent;
@@ -38,7 +34,9 @@ declare_oxc_lint!(
 
 impl Rule for NoAsyncClientComponent {
     fn run_once(&self, ctx: &LintContext) {
-        let Some(root) = ctx.nodes().root_node() else { return };
+        let Some(root) = ctx.nodes().root_node() else {
+            return;
+        };
         let AstKind::Program(program) = root.kind() else { unreachable!() };
 
         if program.directives.iter().any(|directive| directive.directive.as_str() == "use client") {
@@ -57,7 +55,7 @@ impl Rule for NoAsyncClientComponent {
                             .as_ref()
                             .is_some_and(|v| v.name.chars().next().unwrap().is_uppercase())
                     {
-                        ctx.diagnostic(NoAsyncClientComponentDiagnostic(
+                        ctx.diagnostic(no_async_client_component_diagnostic(
                             func_decl.id.as_ref().unwrap().span,
                         ));
                     }
@@ -80,7 +78,7 @@ impl Rule for NoAsyncClientComponent {
                                 // `func.id.name` MUST be > 0 chars
                                 .is_some_and(|v| v.name.chars().next().unwrap().is_uppercase())
                         {
-                            ctx.diagnostic(NoAsyncClientComponentDiagnostic(
+                            ctx.diagnostic(no_async_client_component_diagnostic(
                                 func.id.as_ref().unwrap().span,
                             ));
                         }
@@ -96,7 +94,7 @@ impl Rule for NoAsyncClientComponent {
                                     &var_declarator.init
                                 {
                                     if arrow_expr.r#async {
-                                        ctx.diagnostic(NoAsyncClientComponentDiagnostic(
+                                        ctx.diagnostic(no_async_client_component_diagnostic(
                                             binding_ident.span,
                                         ));
                                     }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_before_interactive_script_outside_document.rs b/crates/oxc_linter/src/rules/nextjs/no_before_interactive_script_outside_document.rs
index 333f5271b23a..31d9fdfc4691 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_before_interactive_script_outside_document.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_before_interactive_script_outside_document.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeName, JSXAttributeValue, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,13 +14,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-before-interactive-script-outside-document): next/script's `beforeInteractive` strategy should not be used outside of `pages/_document.js`")]
-#[diagnostic(
-    severity(warning),
-    help("See https://nextjs.org/docs/messages/no-before-interactive-script-outside-document")
-)]
-struct NoBeforeInteractiveScriptOutsideDocumentDiagnostic(#[label] pub Span);
+fn no_before_interactive_script_outside_document_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-before-interactive-script-outside-document): next/script's `beforeInteractive` strategy should not be used outside of `pages/_document.js`")
+        .with_help("See https://nextjs.org/docs/messages/no-before-interactive-script-outside-document")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoBeforeInteractiveScriptOutsideDocument;
@@ -44,7 +40,9 @@ declare_oxc_lint!(
 impl Rule for NoBeforeInteractiveScriptOutsideDocument {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::JSXOpeningElement(jsx_el) = node.kind() {
-            let Some(file_path) = ctx.file_path().to_str() else { return };
+            let Some(file_path) = ctx.file_path().to_str() else {
+                return;
+            };
             if is_in_app_dir(file_path) {
                 return;
             }
@@ -82,7 +80,7 @@ impl Rule for NoBeforeInteractiveScriptOutsideDocument {
                     {
                         return;
                     }
-                    ctx.diagnostic(NoBeforeInteractiveScriptOutsideDocumentDiagnostic(
+                    ctx.diagnostic(no_before_interactive_script_outside_document_diagnostic(
                         strategy.span,
                     ));
                 }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_css_tags.rs b/crates/oxc_linter/src/rules/nextjs/no_css_tags.rs
index 0f005385657a..5a1f40ad2008 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_css_tags.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_css_tags.rs
@@ -2,19 +2,18 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeName, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, utils::get_string_literal_prop_value, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-css-tags): Do not include stylesheets manually.")]
-#[diagnostic(severity(warning), help("See https://nextjs.org/docs/messages/no-css-tags"))]
-struct NoCssTagsDiagnostic(#[label] pub Span);
+fn no_css_tags_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-css-tags): Do not include stylesheets manually.")
+        .with_help("See https://nextjs.org/docs/messages/no-css-tags")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoCssTags;
@@ -35,7 +34,9 @@ declare_oxc_lint!(
 
 impl Rule for NoCssTags {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else {
+            return;
+        };
 
         let JSXElementName::Identifier(jsx_opening_element_name) = &jsx_opening_element.name else {
             return;
@@ -52,7 +53,9 @@ impl Rule for NoCssTags {
 
         for attr_item in &jsx_opening_element.attributes {
             if let JSXAttributeItem::Attribute(attr) = attr_item {
-                let JSXAttributeName::Identifier(name) = &attr.name else { continue };
+                let JSXAttributeName::Identifier(name) = &attr.name else {
+                    continue;
+                };
 
                 match name.name.as_str() {
                     "rel" => {
@@ -66,15 +69,21 @@ impl Rule for NoCssTags {
             }
         }
 
-        let (Some(rel_attr), Some(href_attr)) = (rel_attr, href_attr) else { return };
+        let (Some(rel_attr), Some(href_attr)) = (rel_attr, href_attr) else {
+            return;
+        };
 
-        let Some(rel_prop_value) = get_string_literal_prop_value(rel_attr) else { return };
-        let Some(href_prop_value) = get_string_literal_prop_value(href_attr) else { return };
+        let Some(rel_prop_value) = get_string_literal_prop_value(rel_attr) else {
+            return;
+        };
+        let Some(href_prop_value) = get_string_literal_prop_value(href_attr) else {
+            return;
+        };
 
         if rel_prop_value == "stylesheet"
             && !(href_prop_value.starts_with("https://") || href_prop_value.starts_with("http://"))
         {
-            ctx.diagnostic(NoCssTagsDiagnostic(jsx_opening_element_name.span));
+            ctx.diagnostic(no_css_tags_diagnostic(jsx_opening_element_name.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_document_import_in_page.rs b/crates/oxc_linter/src/rules/nextjs/no_document_import_in_page.rs
index eafb97a97cb8..09211aaa24e1 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_document_import_in_page.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_document_import_in_page.rs
@@ -1,20 +1,14 @@
 use oxc_ast::{ast::ModuleDeclaration, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, utils::is_document_page, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-document-import-in-page): `<Document />` from `next/document` should not be imported outside of `pages/_document.js`. See: https://nextjs.org/docs/messages/no-document-import-in-page")]
-#[diagnostic(
-    severity(warning),
-    help("Prevent importing `next/document` outside of `pages/_document.js`.")
-)]
-struct NoDocumentImportInPageDiagnostic(#[label] pub Span);
+fn no_document_import_in_page_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-document-import-in-page): `<Document />` from `next/document` should not be imported outside of `pages/_document.js`. See: https://nextjs.org/docs/messages/no-document-import-in-page").with_help("Prevent importing `next/document` outside of `pages/_document.js`.").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDocumentImportInPage;
@@ -45,13 +39,15 @@ impl Rule for NoDocumentImportInPage {
             return;
         }
 
-        let Some(path) = ctx.file_path().to_str() else { return };
+        let Some(path) = ctx.file_path().to_str() else {
+            return;
+        };
 
         if is_document_page(path) {
             return;
         }
 
-        ctx.diagnostic(NoDocumentImportInPageDiagnostic(import_decl.span));
+        ctx.diagnostic(no_document_import_in_page_diagnostic(import_decl.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/nextjs/no_duplicate_head.rs b/crates/oxc_linter/src/rules/nextjs/no_duplicate_head.rs
index b8224b874905..55e3b5e7992c 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_duplicate_head.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_duplicate_head.rs
@@ -1,5 +1,5 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::miette::{miette, LabeledSpan, Severity};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::Reference;
 
@@ -73,12 +73,11 @@ impl Rule for NoDuplicateHead {
             return;
         }
 
-        ctx.diagnostic(miette!(
-            severity = Severity::Warning,
-            labels = labels,
-            help = "Only use a single `<Head />` component in your custom document in `pages/_document.js`. See: https://nextjs.org/docs/messages/no-duplicate-head",
-            "eslint-plugin-next(no-duplicate-head): Do not include multiple instances of `<Head/>`"
-        ));
+        ctx.diagnostic(
+            OxcDiagnostic::warning("eslint-plugin-next(no-duplicate-head): Do not include multiple instances of `<Head/>`")
+                .with_help("Only use a single `<Head />` component in your custom document in `pages/_document.js`. See: https://nextjs.org/docs/messages/no-duplicate-head")
+                .with_labels(labels),
+        );
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/nextjs/no_head_element.rs b/crates/oxc_linter/src/rules/nextjs/no_head_element.rs
index a75cecc72e31..ee6e98cbb952 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_head_element.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_head_element.rs
@@ -1,17 +1,16 @@
 use oxc_ast::{ast::JSXElementName, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, utils::is_in_app_dir, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-head-element): Do not use `<head>` element. Use `<Head />` from `next/head` instead.")]
-#[diagnostic(severity(warning), help("See https://nextjs.org/docs/messages/no-head-element"))]
-struct NoHeadElementDiagnostic(#[label] pub Span);
+fn no_head_element_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-head-element): Do not use `<head>` element. Use `<Head />` from `next/head` instead.")
+        .with_help("See https://nextjs.org/docs/messages/no-head-element")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoHeadElement;
@@ -32,14 +31,18 @@ declare_oxc_lint!(
 
 impl Rule for NoHeadElement {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let Some(full_file_path) = ctx.file_path().to_str() else { return };
+        let Some(full_file_path) = ctx.file_path().to_str() else {
+            return;
+        };
         if is_in_app_dir(full_file_path) {
             return;
         }
         if let AstKind::JSXOpeningElement(elem) = node.kind() {
-            let JSXElementName::Identifier(id) = &elem.name else { return };
+            let JSXElementName::Identifier(id) = &elem.name else {
+                return;
+            };
             if id.name == "head" {
-                ctx.diagnostic(NoHeadElementDiagnostic(elem.span));
+                ctx.diagnostic(no_head_element_diagnostic(elem.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_head_import_in_document.rs b/crates/oxc_linter/src/rules/nextjs/no_head_import_in_document.rs
index 7dd3c679ac2c..896d79b4eb51 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_head_import_in_document.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_head_import_in_document.rs
@@ -1,20 +1,16 @@
 use oxc_ast::{ast::ModuleDeclaration, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-head-import-in-document): Prevent usage of `next/head` in `pages/_document.js`.")]
-#[diagnostic(
-    severity(warning),
-    help("See https://nextjs.org/docs/messages/no-head-import-in-document")
-)]
-struct NoHeadImportInDocumentDiagnostic(#[label] pub Span);
+fn no_head_import_in_document_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-head-import-in-document): Prevent usage of `next/head` in `pages/_document.js`.")
+        .with_help("See https://nextjs.org/docs/messages/no-head-import-in-document")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoHeadImportInDocument;
@@ -52,14 +48,14 @@ impl Rule for NoHeadImportInDocument {
                 // check `_document.*` case
 
                 if file_name.starts_with("_document.") {
-                    ctx.diagnostic(NoHeadImportInDocumentDiagnostic(import_decl.span));
+                    ctx.diagnostic(no_head_import_in_document_diagnostic(import_decl.span));
                 // check `_document/index.*` case
                 } else if file_name.starts_with("index") {
                     if let Some(p) = full_file_path.parent() {
                         if let Some(file_name) = p.file_name() {
                             if let Some(file_name) = file_name.to_str() {
                                 if file_name.starts_with("_document") {
-                                    ctx.diagnostic(NoHeadImportInDocumentDiagnostic(
+                                    ctx.diagnostic(no_head_import_in_document_diagnostic(
                                         import_decl.span,
                                     ));
                                 }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_img_element.rs b/crates/oxc_linter/src/rules/nextjs/no_img_element.rs
index 174c62e94243..bb7d7ff85f99 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_img_element.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_img_element.rs
@@ -1,17 +1,16 @@
 use oxc_ast::{ast::JSXElementName, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-img-element): Prevent usage of `<img>` element due to slower LCP and higher bandwidth.")]
-#[diagnostic(severity(warning), help("See https://nextjs.org/docs/messages/no-img-element"))]
-struct NoImgElementDiagnostic(#[label] pub Span);
+fn no_img_element_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-img-element): Prevent usage of `<img>` element due to slower LCP and higher bandwidth.")
+        .with_help("See https://nextjs.org/docs/messages/no-img-element")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoImgElement;
@@ -32,7 +31,9 @@ declare_oxc_lint!(
 
 impl Rule for NoImgElement {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else {
+            return;
+        };
 
         let JSXElementName::Identifier(jsx_opening_element_name) = &jsx_opening_element.name else {
             return;
@@ -42,8 +43,12 @@ impl Rule for NoImgElement {
             return;
         }
 
-        let Some(parent) = ctx.nodes().parent_node(node.id()) else { return };
-        let Some(parent) = ctx.nodes().parent_node(parent.id()) else { return };
+        let Some(parent) = ctx.nodes().parent_node(node.id()) else {
+            return;
+        };
+        let Some(parent) = ctx.nodes().parent_node(parent.id()) else {
+            return;
+        };
 
         if let AstKind::JSXElement(maybe_picture_jsx_elem) = parent.kind() {
             if let JSXElementName::Identifier(jsx_opening_element_name) =
@@ -55,7 +60,7 @@ impl Rule for NoImgElement {
             }
         }
 
-        ctx.diagnostic(NoImgElementDiagnostic(jsx_opening_element_name.span));
+        ctx.diagnostic(no_img_element_diagnostic(jsx_opening_element_name.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/nextjs/no_page_custom_font.rs b/crates/oxc_linter/src/rules/nextjs/no_page_custom_font.rs
index 1392601032cb..a74a266f827e 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_page_custom_font.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_page_custom_font.rs
@@ -2,29 +2,22 @@ use oxc_ast::{
     ast::{Class, Function, JSXAttributeItem, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoPageCustomFontDiagnostic {
-    #[error("eslint-plugin-next(no-page-custom-font): Custom fonts not added in `pages/_document.js` will only load for a single page. This is discouraged.")]
-    #[diagnostic(
-        severity(warning),
-        help("See: https://nextjs.org/docs/messages/no-page-custom-font")
-    )]
-    NotAddedInDocument(#[label] Span),
-    #[error("eslint-plugin-next(no-page-custom-font): Using `<link />` outside of `<Head>` will disable automatic font optimization. This is discouraged.")]
-    #[diagnostic(
-        severity(warning),
-        help("See: 'https://nextjs.org/docs/messages/no-page-custom-font")
-    )]
-    LinkOutsideOfHead(#[label] Span),
+fn not_added_in_document(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-page-custom-font): Custom fonts not added in `pages/_document.js` will only load for a single page. This is discouraged.")
+        .with_help("See: https://nextjs.org/docs/messages/no-page-custom-font")
+        .with_labels([span0.into()])
+}
+
+fn link_outside_of_head(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-page-custom-font): Using `<link />` outside of `<Head>` will disable automatic font optimization. This is discouraged.")
+        .with_help("See: 'https://nextjs.org/docs/messages/no-page-custom-font")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -47,13 +40,13 @@ declare_oxc_lint!(
 
 impl Rule for NoPageCustomFont {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(element) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(element) = node.kind() else {
+            return;
+        };
         if matches!(&element.name, JSXElementName::Identifier(ident) if ident.name != "link") {
             return;
         }
-        let is_custom_font = element.attributes.iter().any(
-            |attr| matches!(&attr, JSXAttributeItem::Attribute(attr) if attr.is_identifier("href") && attr.value.is_some()),
-        );
+        let is_custom_font = element.attributes.iter().any(|attr| matches!(&attr, JSXAttributeItem::Attribute(attr) if attr.is_identifier("href") && attr.value.is_some()));
 
         if !is_custom_font {
             return;
@@ -118,9 +111,9 @@ impl Rule for NoPageCustomFont {
             if is_inside_export_default {
                 return;
             }
-            NoPageCustomFontDiagnostic::LinkOutsideOfHead(span)
+            link_outside_of_head(span)
         } else {
-            NoPageCustomFontDiagnostic::NotAddedInDocument(span)
+            not_added_in_document(span)
         };
         ctx.diagnostic(diagnostic);
     }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_script_component_in_head.rs b/crates/oxc_linter/src/rules/nextjs/no_script_component_in_head.rs
index bf93d9944719..99cd1c34c597 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_script_component_in_head.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_script_component_in_head.rs
@@ -2,22 +2,18 @@ use oxc_ast::{
     ast::{ImportDeclarationSpecifier, JSXChild, JSXElementName, ModuleDeclaration},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-script-component-in-head): Prevent usage of `next/script` in `next/head` component.")]
-#[diagnostic(
-    severity(warning),
-    help("See https://nextjs.org/docs/messages/no-script-component-in-head")
-)]
-struct NoScriptComponentInHeadDiagnostic(#[label] pub Span);
+fn no_script_component_in_head_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-script-component-in-head): Prevent usage of `next/script` in `next/head` component.")
+        .with_help("See https://nextjs.org/docs/messages/no-script-component-in-head")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoScriptComponentInHead;
@@ -48,7 +44,9 @@ impl Rule for NoScriptComponentInHead {
             return;
         }
 
-        let Some(import_specifiers) = &import_decl.specifiers else { return };
+        let Some(import_specifiers) = &import_decl.specifiers else {
+            return;
+        };
 
         let Some(default_import) = import_specifiers.iter().find_map(|import_specifier| {
             let ImportDeclarationSpecifier::ImportDefaultSpecifier(import_default_specifier) =
@@ -65,9 +63,13 @@ impl Rule for NoScriptComponentInHead {
         for reference in
             ctx.semantic().symbol_references(default_import.local.symbol_id.get().unwrap())
         {
-            let Some(node) = ctx.nodes().parent_node(reference.node_id()) else { return };
+            let Some(node) = ctx.nodes().parent_node(reference.node_id()) else {
+                return;
+            };
 
-            let AstKind::JSXElementName(_) = node.kind() else { continue };
+            let AstKind::JSXElementName(_) = node.kind() else {
+                continue;
+            };
             let parent_node = ctx.nodes().parent_node(node.id()).unwrap();
             let AstKind::JSXOpeningElement(jsx_opening_element) = parent_node.kind() else {
                 continue;
@@ -83,7 +85,7 @@ impl Rule for NoScriptComponentInHead {
                         &child_element.opening_element.name
                     {
                         if child_element_name.name.as_str() == "Script" {
-                            ctx.diagnostic(NoScriptComponentInHeadDiagnostic(
+                            ctx.diagnostic(no_script_component_in_head_diagnostic(
                                 jsx_opening_element.name.span(),
                             ));
                         }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_styled_jsx_in_document.rs b/crates/oxc_linter/src/rules/nextjs/no_styled_jsx_in_document.rs
index 496a6f16627d..d79ed6a7ae7c 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_styled_jsx_in_document.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_styled_jsx_in_document.rs
@@ -2,19 +2,18 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-styled-jsx-in-document): `styled-jsx` should not be used in `pages/_document.js`")]
-#[diagnostic(severity(warning), help("Possible to fix it please see: https://nextjs.org/docs/messages/no-styled-jsx-in-document#possible-ways-to-fix-it"))]
-struct NoStyledJsxInDocumentDiagnostic(#[label] pub Span);
+fn no_styled_jsx_in_document_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-styled-jsx-in-document): `styled-jsx` should not be used in `pages/_document.js`")
+        .with_help("Possible to fix it please see: https://nextjs.org/docs/messages/no-styled-jsx-in-document#possible-ways-to-fix-it")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoStyledJsxInDocument;
@@ -50,17 +49,17 @@ impl Rule for NoStyledJsxInDocument {
         let Some(file_name) = full_file_path.file_name() else {
             return;
         };
-        let Some(file_name) = file_name.to_str() else { return };
+        let Some(file_name) = file_name.to_str() else {
+            return;
+        };
         if !file_name.starts_with("_document.") {
             return;
         }
 
-        let has_jsx_attribute = element.attributes.iter().any(|attribute| {
-					matches!(attribute, JSXAttributeItem::Attribute(attribute) if attribute.is_identifier("jsx"))
-				});
+        let has_jsx_attribute = element.attributes.iter().any(|attribute| matches!(attribute, JSXAttributeItem::Attribute(attribute) if attribute.is_identifier("jsx")));
 
         if has_jsx_attribute {
-            ctx.diagnostic(NoStyledJsxInDocumentDiagnostic(element.span));
+            ctx.diagnostic(no_styled_jsx_in_document_diagnostic(element.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_sync_scripts.rs b/crates/oxc_linter/src/rules/nextjs/no_sync_scripts.rs
index 584976eca362..3d54b1bec1dc 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_sync_scripts.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_sync_scripts.rs
@@ -2,20 +2,19 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeName, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use rustc_hash::FxHashSet;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-sync-scripts): Prevent synchronous scripts.")]
-#[diagnostic(severity(warning), help("See https://nextjs.org/docs/messages/no-sync-scripts"))]
-struct NoSyncScriptsDiagnostic(#[label] pub Span);
+fn no_sync_scripts_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-sync-scripts): Prevent synchronous scripts.")
+        .with_help("See https://nextjs.org/docs/messages/no-sync-scripts")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoSyncScripts;
@@ -36,7 +35,9 @@ declare_oxc_lint!(
 
 impl Rule for NoSyncScripts {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_opening_element) = node.kind() else {
+            return;
+        };
 
         let JSXElementName::Identifier(jsx_opening_element_name) = &jsx_opening_element.name else {
             return;
@@ -46,31 +47,26 @@ impl Rule for NoSyncScripts {
             return;
         }
 
-        let attributes_hs =
-            jsx_opening_element
-                .attributes
-                .iter()
-                .filter_map(|v| {
-                    if let JSXAttributeItem::Attribute(v) = v {
-                        Some(&v.name)
-                    } else {
-                        None
-                    }
-                })
-                .filter_map(|v| {
-                    if let JSXAttributeName::Identifier(v) = v {
-                        Some(v.name.clone())
-                    } else {
-                        None
-                    }
-                })
-                .collect::<FxHashSet<_>>();
+        let attributes_hs = jsx_opening_element
+            .attributes
+            .iter()
+            .filter_map(
+                |v| if let JSXAttributeItem::Attribute(v) = v { Some(&v.name) } else { None },
+            )
+            .filter_map(|v| {
+                if let JSXAttributeName::Identifier(v) = v {
+                    Some(v.name.clone())
+                } else {
+                    None
+                }
+            })
+            .collect::<FxHashSet<_>>();
 
         if attributes_hs.contains("src")
             && !attributes_hs.contains("async")
             && !attributes_hs.contains("defer")
         {
-            ctx.diagnostic(NoSyncScriptsDiagnostic(jsx_opening_element_name.span));
+            ctx.diagnostic(no_sync_scripts_diagnostic(jsx_opening_element_name.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_title_in_document_head.rs b/crates/oxc_linter/src/rules/nextjs/no_title_in_document_head.rs
index 11c83760c39b..7dda989b4e32 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_title_in_document_head.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_title_in_document_head.rs
@@ -2,22 +2,18 @@ use oxc_ast::{
     ast::{ImportDeclarationSpecifier, JSXChild, JSXElementName, ModuleDeclaration},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-title-in-document-head): Prevent usage of `<title>` with `Head` component from `next/document`.")]
-#[diagnostic(
-    severity(warning),
-    help("See https://nextjs.org/docs/messages/no-title-in-document-head")
-)]
-struct NoTitleInDocumentHeadDiagnostic(#[label] pub Span);
+fn no_title_in_document_head_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-next(no-title-in-document-head): Prevent usage of `<title>` with `Head` component from `next/document`.")
+        .with_help("See https://nextjs.org/docs/messages/no-title-in-document-head")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoTitleInDocumentHead;
@@ -48,7 +44,9 @@ impl Rule for NoTitleInDocumentHead {
             return;
         }
 
-        let Some(import_specifiers) = &import_decl.specifiers else { return };
+        let Some(import_specifiers) = &import_decl.specifiers else {
+            return;
+        };
 
         let Some(default_import) = import_specifiers.iter().find_map(|import_specifier| {
             let ImportDeclarationSpecifier::ImportSpecifier(import_default_specifier) =
@@ -65,9 +63,13 @@ impl Rule for NoTitleInDocumentHead {
         for reference in
             ctx.semantic().symbol_references(default_import.local.symbol_id.get().unwrap())
         {
-            let Some(node) = ctx.nodes().parent_node(reference.node_id()) else { return };
+            let Some(node) = ctx.nodes().parent_node(reference.node_id()) else {
+                return;
+            };
 
-            let AstKind::JSXElementName(_) = node.kind() else { continue };
+            let AstKind::JSXElementName(_) = node.kind() else {
+                continue;
+            };
             let parent_node = ctx.nodes().parent_node(node.id()).unwrap();
             let AstKind::JSXOpeningElement(jsx_opening_element) = parent_node.kind() else {
                 continue;
@@ -83,7 +85,7 @@ impl Rule for NoTitleInDocumentHead {
                         &child_element.opening_element.name
                     {
                         if child_element_name.name.as_str() == "title" {
-                            ctx.diagnostic(NoTitleInDocumentHeadDiagnostic(
+                            ctx.diagnostic(no_title_in_document_head_diagnostic(
                                 jsx_opening_element.name.span(),
                             ));
                         }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_typos.rs b/crates/oxc_linter/src/rules/nextjs/no_typos.rs
index cfb6450c78d8..0c7e132f7ab4 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_typos.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_typos.rs
@@ -2,20 +2,21 @@ use oxc_ast::{
     ast::{BindingPatternKind, Declaration, ModuleDeclaration},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::phf_set;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-typos): {0} may be a typo. Did you mean {1}?")]
-#[diagnostic(severity(warning), help("Prevent common typos in Next.js's data fetching functions"))]
-struct NoTyposDiagnostic(String, String, #[label] pub Span);
+fn no_typos_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-next(no-typos): {x0} may be a typo. Did you mean {x1}?"
+    ))
+    .with_help("Prevent common typos in Next.js's data fetching functions")
+    .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoTypos;
@@ -49,8 +50,12 @@ const THRESHOLD: i32 = 1;
 
 impl Rule for NoTypos {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let Some(path) = ctx.file_path().to_str() else { return };
-        let Some(path_after_pages) = path.split("pages").nth(1) else { return };
+        let Some(path) = ctx.file_path().to_str() else {
+            return;
+        };
+        let Some(path_after_pages) = path.split("pages").nth(1) else {
+            return;
+        };
         if path_after_pages.starts_with("/api") {
             return;
         }
@@ -67,19 +72,21 @@ impl Rule for NoTypos {
                             let Some(potential_typo) = get_potential_typo(&id.name) else {
                                 continue;
                             };
-                            ctx.diagnostic(NoTyposDiagnostic(
-                                id.name.to_string(),
-                                potential_typo.to_string(),
+                            ctx.diagnostic(no_typos_diagnostic(
+                                id.name.as_str(),
+                                potential_typo,
                                 id.span,
                             ));
                         }
                     }
                     Declaration::FunctionDeclaration(decl) => {
                         let Some(id) = &decl.id else { return };
-                        let Some(potential_typo) = get_potential_typo(&id.name) else { return };
-                        ctx.diagnostic(NoTyposDiagnostic(
-                            id.name.to_string(),
-                            potential_typo.to_string(),
+                        let Some(potential_typo) = get_potential_typo(&id.name) else {
+                            return;
+                        };
+                        ctx.diagnostic(no_typos_diagnostic(
+                            id.name.as_str(),
+                            potential_typo,
                             id.span,
                         ));
                     }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_unwanted_polyfillio.rs b/crates/oxc_linter/src/rules/nextjs/no_unwanted_polyfillio.rs
index fb11ffefd435..6c9f4e5838ed 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_unwanted_polyfillio.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_unwanted_polyfillio.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeName, JSXAttributeValue, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNode;
 use oxc_span::Span;
@@ -13,13 +11,11 @@ use phf::{phf_set, Set};
 
 use crate::{context::LintContext, rule::Rule, utils::get_next_script_import_local_name};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-next(no-unwanted-polyfillio): No duplicate polyfills from Polyfill.io are allowed. {0} already shipped with Next.js.")]
-#[diagnostic(
-    severity(warning),
-    help("See https://nextjs.org/docs/messages/no-unwanted-polyfillio")
-)]
-struct NoUnwantedPolyfillioDiagnostic(String, #[label] pub Span);
+fn no_unwanted_polyfillio_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-next(no-unwanted-polyfillio): No duplicate polyfills from Polyfill.io are allowed. {x0} already shipped with Next.js."))
+        .with_help("See https://nextjs.org/docs/messages/no-unwanted-polyfillio")
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnwantedPolyfillio;
@@ -160,8 +156,8 @@ impl Rule for NoUnwantedPolyfillio {
                         .filter(|feature| NEXT_POLYFILLED_FEATURES.contains(feature))
                         .collect();
                     if !unwanted_features.is_empty() {
-                        ctx.diagnostic(NoUnwantedPolyfillioDiagnostic(
-                            format!(
+                        ctx.diagnostic(no_unwanted_polyfillio_diagnostic(
+                            &format!(
                                 "{} {}",
                                 unwanted_features.join(", "),
                                 if unwanted_features.len() > 1 { "are" } else { "is" }
diff --git a/crates/oxc_linter/src/rules/oxc/approx_constant.rs b/crates/oxc_linter/src/rules/oxc/approx_constant.rs
index 6dbf802e4a9e..ac96b724416a 100644
--- a/crates/oxc_linter/src/rules/oxc/approx_constant.rs
+++ b/crates/oxc_linter/src/rules/oxc/approx_constant.rs
@@ -1,20 +1,19 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 // Based on https://github.com/rust-lang/rust-clippy//blob/c9a43b18f11219fa70fe632b29518581fcd589c8/clippy_lints/src/approx_const.rs
 // https://rust-lang.github.io/rust-clippy/master/#approx_constant
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use std::f64::consts as f64;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("oxc(approx-constant): Approximate value of `{1}` found.")]
-#[diagnostic(severity(warning), help("Use `Math.{1}` instead"))]
-struct ApproxConstantDiagnostic(#[label] pub Span, pub &'static str);
+fn approx_constant_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("oxc(approx-constant): Approximate value of `{x1}` found."))
+        .with_help(format!("Use `Math.{x1}` instead"))
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ApproxConstant;
@@ -44,7 +43,7 @@ impl Rule for ApproxConstant {
         let number_lit_str = number_literal.value.to_string();
         for (constant, name, min_digits) in &KNOWN_CONSTS {
             if is_approx_const(*constant, &number_lit_str, *min_digits) {
-                ctx.diagnostic(ApproxConstantDiagnostic(number_literal.span, name));
+                ctx.diagnostic(approx_constant_diagnostic(number_literal.span, name));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/oxc/const_comparisons.rs b/crates/oxc_linter/src/rules/oxc/const_comparisons.rs
index 9bc20afc68a1..4fae951040f5 100644
--- a/crates/oxc_linter/src/rules/oxc/const_comparisons.rs
+++ b/crates/oxc_linter/src/rules/oxc/const_comparisons.rs
@@ -5,41 +5,40 @@ use oxc_ast::{
     ast::{Expression, NumericLiteral},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{BinaryOperator, LogicalOperator};
 
 use crate::{context::LintContext, rule::Rule, utils::is_same_reference, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum ConstComparisonsDiagnostic {
-    #[error("oxc(const-comparisons): Left-hand side of `&&` operator has no effect.")]
-    #[diagnostic(severity(warning), help("{2}"))]
-    RedundantLeftHandSide(
-        #[label("If this evaluates to `true`")] Span,
-        #[label("This will always evaluate to true.")] Span,
-        String,
-    ),
-    #[error("oxc(const-comparisons): Right-hand side of `&&` operator has no effect.")]
-    #[diagnostic(severity(warning), help("{2}"))]
-    RedundantRightHandSide(
-        #[label("If this evaluates to `true`")] Span,
-        #[label("This will always evaluate to true.")] Span,
-        String,
-    ),
-    #[error("oxc(const-comparisons): Unexpected constant comparison")]
-    #[diagnostic(severity(warning), help("{4}"))]
-    Impossible(
-        #[label("Requires that {2}")] Span,
-        #[label("Requires that {3}")] Span,
-        String,
-        String,
-        String,
-    ),
+fn redundant_left_hand_side(span0: Span, span1: Span, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("oxc(const-comparisons): Left-hand side of `&&` operator has no effect.")
+        .with_help(x2.to_string())
+        .with_labels([
+            LabeledSpan::new_with_span(Some("If this evaluates to `true`".into()), span0),
+            LabeledSpan::new_with_span(Some("This will always evaluate to true.".into()), span1),
+        ])
+}
+
+fn redundant_right_hand_side(span0: Span, span1: Span, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "oxc(const-comparisons): Right-hand side of `&&` operator has no effect.",
+    )
+    .with_help(x2.to_string())
+    .with_labels([
+        LabeledSpan::new_with_span(Some("If this evaluates to `true`".into()), span0),
+        LabeledSpan::new_with_span(Some("This will always evaluate to true.".into()), span1),
+    ])
+}
+
+fn impossible(span0: Span, span1: Span, x2: &str, x3: &str, x4: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("oxc(const-comparisons): Unexpected constant comparison")
+        .with_help(x4.to_string())
+        .with_labels([
+            LabeledSpan::new_with_span(Some(format!("Requires that {x2}")), span0),
+            LabeledSpan::new_with_span(Some(format!("Requires that {x3}")), span1),
+        ])
 }
 
 /// <https://rust-lang.github.io/rust-clippy/master/index.html#/impossible>
@@ -116,50 +115,38 @@ impl Rule for ConstComparisons {
                 // We already know that either side of `&&` has no effect,
                 // but emit a different error message depending on which side it is
                 if left_side_is_useless(left_cmp_op, ordering) {
-                    ctx.diagnostic(ConstComparisonsDiagnostic::RedundantLeftHandSide(
-                        left_span,
-                        logical_expr.right.span(),
-                        format!("if `{rhs_str}` evaluates to true, `{lhs_str}` will always evaluate to true as well")
-                    ));
+                    ctx.diagnostic(redundant_left_hand_side(left_span, logical_expr.right.span(), &format!("if `{rhs_str}` evaluates to true, `{lhs_str}` will always evaluate to true as well")));
                 } else {
-                    ctx.diagnostic(ConstComparisonsDiagnostic::RedundantRightHandSide(
-                        logical_expr.right.span(),
-                        left_span,
-                        format!("if `{lhs_str}` evaluates to true, `{rhs_str}` will always evaluate to true as well")
-                    ));
+                    ctx.diagnostic(redundant_right_hand_side(logical_expr.right.span(), left_span, &format!("if `{lhs_str}` evaluates to true, `{rhs_str}` will always evaluate to true as well")));
                 }
             } else if !comparison_is_possible(left_cmp_op.direction(), ordering) {
                 let lhs_str = left_const_expr.span.source_text(ctx.source_text());
                 let rhs_str = right_const_expr.span.source_text(ctx.source_text());
                 let expr_str = left_expr.span().source_text(ctx.source_text());
                 let diagnostic_note = match ordering {
-                    Ordering::Less => format!(
-                        "since `{lhs_str}` < `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"
-                    ),
+                    Ordering::Less => format!("since `{lhs_str}` < `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
                     Ordering::Equal => {
                         format!("`{expr_str}` cannot simultaneously be greater than and less than `{lhs_str}`")
-                    },
-                    Ordering::Greater => format!(
-                        "since `{lhs_str}` > `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"
-                    ),
+                    }
+                    Ordering::Greater => format!("since `{lhs_str}` > `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
                 };
 
-                ctx.diagnostic(ConstComparisonsDiagnostic::Impossible(
+                ctx.diagnostic(impossible(
                     left_span,
                     logical_expr.right.without_parenthesized().span(),
-                    format!(
+                    &format!(
                         "`{} {} {}` ",
                         expr_str,
                         left_cmp_op,
                         left_const_expr.span.source_text(ctx.source_text())
                     ),
-                    format!(
+                    &format!(
                         "`{} {} {}` ",
                         expr_str,
                         right_cmp_op,
                         right_const_expr.span.source_text(ctx.source_text())
                     ),
-                    diagnostic_note,
+                    &diagnostic_note,
                 ));
             }
         }
diff --git a/crates/oxc_linter/src/rules/oxc/double_comparisons.rs b/crates/oxc_linter/src/rules/oxc/double_comparisons.rs
index 8e9fb0d9bd36..2d18b542edd2 100644
--- a/crates/oxc_linter/src/rules/oxc/double_comparisons.rs
+++ b/crates/oxc_linter/src/rules/oxc/double_comparisons.rs
@@ -1,21 +1,19 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::{BinaryOperator, LogicalOperator};
 
 use crate::{context::LintContext, rule::Rule, utils::is_same_reference, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("oxc(double-comparisons): Unexpected double comparisons.")]
-#[diagnostic(
-    severity(warning),
-    help("This logical expression can be simplified. Try using the `{1}` operator instead.")
-)]
-struct DoubleComparisonsDiagnostic(#[label] pub Span, &'static str);
+fn double_comparisons_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("oxc(double-comparisons): Unexpected double comparisons.")
+        .with_help(format!(
+            "This logical expression can be simplified. Try using the `{x1}` operator instead."
+        ))
+        .with_labels([span0.into()])
+}
 
 /// <https://rust-lang.github.io/rust-clippy/master/index.html#/double_comparisons>
 #[derive(Debug, Default, Clone)]
@@ -87,7 +85,7 @@ impl Rule for DoubleComparisons {
             _ => return,
         };
 
-        ctx.diagnostic(DoubleComparisonsDiagnostic(logical_expr.span, new_op));
+        ctx.diagnostic(double_comparisons_diagnostic(logical_expr.span, new_op));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/oxc/erasing_op.rs b/crates/oxc_linter/src/rules/oxc/erasing_op.rs
index 8c095932055f..0e21e96a5622 100644
--- a/crates/oxc_linter/src/rules/oxc/erasing_op.rs
+++ b/crates/oxc_linter/src/rules/oxc/erasing_op.rs
@@ -1,24 +1,21 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 // Based on https://github.com/rust-lang/rust-clippy//blob/00e9372987755dece96561ef2eef0785c8742e55/clippy_lints/src/operators/erasing_op.rs
 use oxc_ast::{
     ast::{BinaryExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::BinaryOperator;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "oxc(erasing-op): Unexpected erasing operation. This expression will always evaluate to zero."
-)]
-#[diagnostic(severity(warning), help("This is most likely not the intended outcome. Consider removing the operation, or directly assigning zero to the variable"))]
-struct ErasingOpDiagnostic(#[label] pub Span);
+fn erasing_op_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("oxc(erasing-op): Unexpected erasing operation. This expression will always evaluate to zero.")
+        .with_help("This is most likely not the intended outcome. Consider removing the operation, or directly assigning zero to the variable")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ErasingOp;
@@ -50,7 +47,9 @@ declare_oxc_lint!(
 
 impl Rule for ErasingOp {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::BinaryExpression(binary_expression) = node.kind() else { return };
+        let AstKind::BinaryExpression(binary_expression) = node.kind() else {
+            return;
+        };
 
         match binary_expression.operator {
             BinaryOperator::Multiplication | BinaryOperator::BitwiseAnd => {
@@ -82,7 +81,7 @@ fn check_op<'a, 'b>(
     ctx: &LintContext<'a>,
 ) {
     if is_number_value(op, 0.0) {
-        ctx.diagnostic(ErasingOpDiagnostic(binary_expression.span));
+        ctx.diagnostic(erasing_op_diagnostic(binary_expression.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/oxc/misrefactored_assign_op.rs b/crates/oxc_linter/src/rules/oxc/misrefactored_assign_op.rs
index bb9a52b27c0b..8024a2ebd79c 100644
--- a/crates/oxc_linter/src/rules/oxc/misrefactored_assign_op.rs
+++ b/crates/oxc_linter/src/rules/oxc/misrefactored_assign_op.rs
@@ -1,12 +1,10 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 // Based on https://github.com/rust-lang/rust-clippy//blob/c9a43b18f11219fa70fe632b29518581fcd589c8/clippy_lints/src/operators/misrefactored_assign_op.rs
 use oxc_ast::{
     ast::{match_member_expression, AssignmentTarget, Expression, SimpleAssignmentTarget},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator};
@@ -18,10 +16,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("oxc(misrefactored-assign-op): Misrefactored assign op. Variable appears on both sides of an assignment operation")]
-#[diagnostic(severity(warning), help("Did you mean `{1}`?"))]
-struct MisrefactoredAssignOpDiagnostic(#[label] pub Span, pub String);
+fn misrefactored_assign_op_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("oxc(misrefactored-assign-op): Misrefactored assign op. Variable appears on both sides of an assignment operation")
+        .with_help(format!("Did you mean `{x1}`?"))
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct MisrefactoredAssignOp;
@@ -64,9 +63,9 @@ impl Rule for MisrefactoredAssignOp {
 
             // lhs op= l op r
             if assignment_target_eq_expr(&assignment_expr.left, &binary_expr.left, ctx) {
-                ctx.diagnostic(MisrefactoredAssignOpDiagnostic(
+                ctx.diagnostic(misrefactored_assign_op_diagnostic(
                     assignment_expr.span,
-                    format!(
+                    &format!(
                         "{} {} {}",
                         assignment_expr.left.span().source_text(ctx.source_text()),
                         assignment_expr.operator.as_str(),
@@ -79,9 +78,9 @@ impl Rule for MisrefactoredAssignOp {
             if is_commutative_operator(binary_expr.operator)
                 && assignment_target_eq_expr(&assignment_expr.left, &binary_expr.right, ctx)
             {
-                ctx.diagnostic(MisrefactoredAssignOpDiagnostic(
+                ctx.diagnostic(misrefactored_assign_op_diagnostic(
                     assignment_expr.span,
-                    format!(
+                    &format!(
                         "{} {} {}",
                         assignment_expr.left.span().source_text(ctx.source_text()),
                         assignment_expr.operator.as_str(),
diff --git a/crates/oxc_linter/src/rules/oxc/no_accumulating_spread.rs b/crates/oxc_linter/src/rules/oxc/no_accumulating_spread.rs
index 22b5b038ff27..4b97fc7d5418 100644
--- a/crates/oxc_linter/src/rules/oxc/no_accumulating_spread.rs
+++ b/crates/oxc_linter/src/rules/oxc/no_accumulating_spread.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Argument, BindingPatternKind, CallExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::SymbolId;
 use oxc_span::Span;
@@ -17,17 +15,18 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoAccumulatingSpreadDiagnostic {
-    #[error("oxc(no-accumulating-spread): Do not spread accumulators in Array.prototype.reduce()")]
-    #[diagnostic(severity(warning), help("It looks like you're spreading an `Array`. Consider using the `Array.push` or `Array.concat` methods to mutate the accumulator instead.\nUsing spreads within accumulators leads to `O(n^2)` time complexity."))]
-    LikelyArray(#[label("From this spread")] Span, #[label("For this reduce")] Span),
-    #[error("oxc(no-accumulating-spread): Do not spread accumulators in Array.prototype.reduce()")]
-    #[diagnostic(severity(warning), help("It looks like you're spreading an `Object`. Consider using the `Object.assign` or assignment operators to mutate the accumulator instead.\nUsing spreads within accumulators leads to `O(n^2)` time complexity."))]
-    LikelyObject(#[label("From this spread")] Span, #[label("For this reduce")] Span),
-    #[error("oxc(no-accumulating-spread): Do not spread accumulators in Array.prototype.reduce()")]
-    #[diagnostic(severity(warning), help("Consider using `Object.assign()` or `Array.prototype.push()` to mutate the accumulator instead.\nUsing spreads within accumulators leads to `O(n^2)` time complexity."))]
-    Unknown(#[label("From this spread")] Span, #[label("For this reduce")] Span),
+fn likely_array(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("oxc(no-accumulating-spread): Do not spread accumulators in Array.prototype.reduce()").with_help("It looks like you're spreading an `Array`. Consider using the `Array.push` or `Array.concat` methods to mutate the accumulator instead.\nUsing spreads within accumulators leads to `O(n^2)` time complexity.").with_labels([LabeledSpan::new_with_span(Some("From this spread".into()), span0), LabeledSpan::new_with_span(Some("For this reduce".into()), span1)])
+}
+
+fn likely_object(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("oxc(no-accumulating-spread): Do not spread accumulators in Array.prototype.reduce()").with_help("It looks like you're spreading an `Object`. Consider using the `Object.assign` or assignment operators to mutate the accumulator instead.\nUsing spreads within accumulators leads to `O(n^2)` time complexity.").with_labels([LabeledSpan::new_with_span(Some("From this spread".into()), span0), LabeledSpan::new_with_span(Some("For this reduce".into()), span1)])
+}
+
+fn unknown(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("oxc(no-accumulating-spread): Do not spread accumulators in Array.prototype.reduce()")
+        .with_help("Consider using `Object.assign()` or `Array.prototype.push()` to mutate the accumulator instead.\nUsing spreads within accumulators leads to `O(n^2)` time complexity.")
+        .with_labels([LabeledSpan::new_with_span(Some("From this spread".into()), span0), LabeledSpan::new_with_span(Some("For this reduce".into()), span1)])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -78,18 +77,28 @@ declare_oxc_lint!(
 impl Rule for NoAccumulatingSpread {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         // only check spreads on identifiers
-        let AstKind::SpreadElement(spread) = node.kind() else { return };
-        let Expression::Identifier(ref ident) = spread.argument else { return };
+        let AstKind::SpreadElement(spread) = node.kind() else {
+            return;
+        };
+        let Expression::Identifier(ref ident) = spread.argument else {
+            return;
+        };
 
         let nodes = ctx.semantic().nodes();
         let symbols = ctx.semantic().symbols();
 
         // get the AST node + symbol id of the declaration of the identifier
-        let Some(reference_id) = ident.reference_id.get() else { return };
+        let Some(reference_id) = ident.reference_id.get() else {
+            return;
+        };
         let reference = symbols.get_reference(reference_id);
-        let Some(referenced_symbol_id) = reference.symbol_id() else { return };
+        let Some(referenced_symbol_id) = reference.symbol_id() else {
+            return;
+        };
         let declaration_id = symbols.get_declaration(referenced_symbol_id);
-        let Some(declaration) = ctx.semantic().nodes().parent_node(declaration_id) else { return };
+        let Some(declaration) = ctx.semantic().nodes().parent_node(declaration_id) else {
+            return;
+        };
         let AstKind::FormalParameters(params) = declaration.kind() else {
             return;
         };
@@ -126,10 +135,7 @@ impl Rule for NoAccumulatingSpread {
     }
 }
 
-fn get_diagnostic<'a>(
-    call_expr: &'a CallExpression<'a>,
-    spread_span: Span,
-) -> NoAccumulatingSpreadDiagnostic {
+fn get_diagnostic<'a>(call_expr: &'a CallExpression<'a>, spread_span: Span) -> OxcDiagnostic {
     // unwrap is safe because we already checked that this is a reduce call
     let (reduce_call_span, _) = call_expr_method_callee_info(call_expr).unwrap();
 
@@ -143,13 +149,13 @@ fn get_diagnostic<'a>(
             };
 
         if matches!(second_arg, Expression::ObjectExpression(_)) {
-            return NoAccumulatingSpreadDiagnostic::LikelyObject(spread_span, reduce_call_span);
+            return likely_object(spread_span, reduce_call_span);
         } else if matches!(second_arg, Expression::ArrayExpression(_)) {
-            return NoAccumulatingSpreadDiagnostic::LikelyArray(spread_span, reduce_call_span);
+            return likely_array(spread_span, reduce_call_span);
         }
     }
 
-    NoAccumulatingSpreadDiagnostic::Unknown(spread_span, reduce_call_span)
+    unknown(spread_span, reduce_call_span)
 }
 
 fn get_identifier_symbol_id(ident: &BindingPatternKind<'_>) -> Option<SymbolId> {
diff --git a/crates/oxc_linter/src/rules/oxc/no_barrel_file.rs b/crates/oxc_linter/src/rules/oxc/no_barrel_file.rs
index 233349f85360..f4c5ba031c93 100644
--- a/crates/oxc_linter/src/rules/oxc/no_barrel_file.rs
+++ b/crates/oxc_linter/src/rules/oxc/no_barrel_file.rs
@@ -1,23 +1,22 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::module_graph_visitor::{ModuleGraphVisitorBuilder, VisitFoldWhile};
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "oxc(no-barrel-file): \
+fn no_barrel_file_diagnostic(span: Span, x1: u32) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "oxc(no-barrel-file): \
             Avoid barrel files, they slow down performance, \
             and cause large module graphs with modules that go unused.\n\
-            Loading this barrel file results in importing {1:?} modules."
-)]
-#[diagnostic(severity(warning), help("For more information visit this link: <https://marvinh.dev/blog/speeding-up-javascript-ecosystem-part-7/>"))]
-struct NoBarrelFileDiagnostic(#[label] pub Span, pub u32);
+            Loading this barrel file results in importing {x1} modules."
+    ))
+    .with_help("For more information visit this link: <https://marvinh.dev/blog/speeding-up-javascript-ecosystem-part-7/>")
+    .with_label(span)
+}
 
 /// Minimum amount of exports to consider module as barrelfile
 const AMOUNT_OF_EXPORTS_TO_CONSIDER_MODULE_AS_BARREL: u8 = 3;
@@ -74,7 +73,7 @@ impl Rule for NoBarrelFile {
             let loaded_modules_count = ModuleGraphVisitorBuilder::default()
                 .visit_fold(0, module_record, |acc, _, _| VisitFoldWhile::Next(acc + 1))
                 .result;
-            ctx.diagnostic(NoBarrelFileDiagnostic(program.span, loaded_modules_count));
+            ctx.diagnostic(no_barrel_file_diagnostic(program.span, loaded_modules_count));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/oxc/only_used_in_recursion.rs b/crates/oxc_linter/src/rules/oxc/only_used_in_recursion.rs
index 8e6f71d5d218..4c8619649820 100644
--- a/crates/oxc_linter/src/rules/oxc/only_used_in_recursion.rs
+++ b/crates/oxc_linter/src/rules/oxc/only_used_in_recursion.rs
@@ -2,24 +2,22 @@ use oxc_ast::{
     ast::{BindingIdentifier, BindingPatternKind, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, GetSpan, Span};
+use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("oxc(only-used-in-recursion): Parameter `{1}` is only used in recursive calls")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "Remove the argument and its usage. Alternatively, use the argument in the function body."
+fn only_used_in_recursion_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "oxc(only-used-in-recursion): Parameter `{x1}` is only used in recursive calls"
+    ))
+    .with_help(
+        "Remove the argument and its usage. Alternatively, use the argument in the function body.",
     )
-)]
-struct OnlyUsedInRecursionDiagnostic(#[label] pub Span, pub CompactStr);
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct OnlyUsedInRecursion;
@@ -63,9 +61,13 @@ declare_oxc_lint!(
 
 impl Rule for OnlyUsedInRecursion {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::Function(function) = node.kind() else { return };
+        let AstKind::Function(function) = node.kind() else {
+            return;
+        };
 
-        let Some(function_id) = &function.id else { return };
+        let Some(function_id) = &function.id else {
+            return;
+        };
 
         if function.is_typescript_syntax() {
             return;
@@ -76,10 +78,12 @@ impl Rule for OnlyUsedInRecursion {
         }
 
         for (arg_index, arg) in function.params.items.iter().enumerate() {
-            let BindingPatternKind::BindingIdentifier(arg) = &arg.pattern.kind else { continue };
+            let BindingPatternKind::BindingIdentifier(arg) = &arg.pattern.kind else {
+                continue;
+            };
 
             if is_argument_only_used_in_recursion(function_id, arg, arg_index, ctx) {
-                ctx.diagnostic(OnlyUsedInRecursionDiagnostic(arg.span, arg.name.to_compact_str()));
+                ctx.diagnostic(only_used_in_recursion_diagnostic(arg.span, arg.name.as_str()));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/react/button_has_type.rs b/crates/oxc_linter/src/rules/react/button_has_type.rs
index b8cac5d83451..3b5a4cdede49 100644
--- a/crates/oxc_linter/src/rules/react/button_has_type.rs
+++ b/crates/oxc_linter/src/rules/react/button_has_type.rs
@@ -5,10 +5,7 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -19,15 +16,16 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum ButtonHasTypeDiagnostic {
-    #[error("eslint-plugin-react(button-has-type): `button` elements must have an explicit `type` attribute.")]
-    #[diagnostic(severity(warning), help("Add a `type` attribute to the `button` element."))]
-    MissingTypeProp(#[label] Span),
+fn missing_type_prop(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(button-has-type): `button` elements must have an explicit `type` attribute.")
+        .with_help("Add a `type` attribute to the `button` element.")
+        .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-react(button-has-type): `button` elements must have a valid `type` attribute.")]
-    #[diagnostic(severity(warning), help("Change the `type` attribute to one of the allowed values: `button`, `submit`, or `reset`."))]
-    InvalidTypeProp(#[label] Span),
+fn invalid_type_prop(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(button-has-type): `button` elements must have a valid `type` attribute.")
+        .with_help("Change the `type` attribute to one of the allowed values: `button`, `submit`, or `reset`.")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Clone)]
@@ -81,13 +79,11 @@ impl Rule for ButtonHasType {
 
                 has_jsx_prop_lowercase(jsx_el, "type").map_or_else(
                     || {
-                        ctx.diagnostic(ButtonHasTypeDiagnostic::MissingTypeProp(identifier.span));
+                        ctx.diagnostic(missing_type_prop(identifier.span));
                     },
                     |button_type_prop| {
                         if !self.is_valid_button_type_prop(button_type_prop) {
-                            ctx.diagnostic(ButtonHasTypeDiagnostic::InvalidTypeProp(
-                                button_type_prop.span(),
-                            ));
+                            ctx.diagnostic(invalid_type_prop(button_type_prop.span()));
                         }
                     },
                 );
@@ -117,21 +113,17 @@ impl Rule for ButtonHasType {
                             })
                             .map_or_else(
                                 || {
-                                    ctx.diagnostic(ButtonHasTypeDiagnostic::MissingTypeProp(
-                                        obj_expr.span,
-                                    ));
+                                    ctx.diagnostic(missing_type_prop(obj_expr.span));
                                 },
                                 |type_prop| {
                                     if !self.is_valid_button_type_prop_expression(&type_prop.value)
                                     {
-                                        ctx.diagnostic(ButtonHasTypeDiagnostic::InvalidTypeProp(
-                                            type_prop.span,
-                                        ));
+                                        ctx.diagnostic(invalid_type_prop(type_prop.span));
                                     }
                                 },
                             );
                     } else {
-                        ctx.diagnostic(ButtonHasTypeDiagnostic::MissingTypeProp(call_expr.span));
+                        ctx.diagnostic(missing_type_prop(call_expr.span));
                     }
                 }
             }
@@ -253,7 +245,7 @@ fn test() {
 			              },
 			            },
 			          ];
-			
+
 			          return <>
 			            {
 			              buttonProps.map(
diff --git a/crates/oxc_linter/src/rules/react/checked_requires_onchange_or_readonly.rs b/crates/oxc_linter/src/rules/react/checked_requires_onchange_or_readonly.rs
index c9b10e43c4e5..472ff6732cae 100644
--- a/crates/oxc_linter/src/rules/react/checked_requires_onchange_or_readonly.rs
+++ b/crates/oxc_linter/src/rules/react/checked_requires_onchange_or_readonly.rs
@@ -2,10 +2,7 @@ use oxc_ast::{
     ast::{Argument, JSXAttributeItem, ObjectPropertyKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,15 +13,16 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum CheckedRequiresOnchangeOrReadonlyDiagnostic {
-    #[error("eslint-plugin-react(checked-requires-onchange-or-readonly): `checked` should be used with either `onChange` or `readOnly`.")]
-    #[diagnostic(severity(warning), help("Add either `onChange` or `readOnly`."))]
-    MissingProperty(#[label] Span),
+fn missing_property(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(checked-requires-onchange-or-readonly): `checked` should be used with either `onChange` or `readOnly`.")
+        .with_help("Add either `onChange` or `readOnly`.")
+        .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-react(checked-requires-onchange-or-readonly): Use either `checked` or `defaultChecked`, but not both.")]
-    #[diagnostic(severity(warning), help("Remove either `checked` or `defaultChecked`."))]
-    ExclusiveCheckedAttribute(#[label] Span, #[label] Span),
+fn exclusive_checked_attribute(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(checked-requires-onchange-or-readonly): Use either `checked` or `defaultChecked`, but not both.")
+        .with_help("Remove either `checked` or `defaultChecked`.")
+        .with_labels([span0.into(), span1.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -68,7 +66,9 @@ impl Rule for CheckedRequiresOnchangeOrReadonly {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         match node.kind() {
             AstKind::JSXOpeningElement(jsx_opening_el) => {
-                let Some(element_type) = get_element_type(ctx, jsx_opening_el) else { return };
+                let Some(element_type) = get_element_type(ctx, jsx_opening_el) else {
+                    return;
+                };
                 if element_type != "input" {
                     return;
                 }
@@ -102,21 +102,15 @@ impl Rule for CheckedRequiresOnchangeOrReadonly {
                 if let Some(checked_span) = checked_span {
                     if !self.ignore_exclusive_checked_attribute {
                         if let Some(default_checked_span) = default_checked_span {
-                            ctx.diagnostic(
-                                CheckedRequiresOnchangeOrReadonlyDiagnostic::ExclusiveCheckedAttribute(
-                                    checked_span,
-                                    default_checked_span,
-                                ),
-                            );
+                            ctx.diagnostic(exclusive_checked_attribute(
+                                checked_span,
+                                default_checked_span,
+                            ));
                         }
                     }
 
                     if !self.ignore_missing_properties && is_missing_property {
-                        ctx.diagnostic(
-                            CheckedRequiresOnchangeOrReadonlyDiagnostic::MissingProperty(
-                                checked_span,
-                            ),
-                        );
+                        ctx.diagnostic(missing_property(checked_span));
                     }
                 }
             }
@@ -172,21 +166,15 @@ impl Rule for CheckedRequiresOnchangeOrReadonly {
                 if let Some(checked_span) = checked_span {
                     if !self.ignore_exclusive_checked_attribute {
                         if let Some(default_checked_span) = default_checked_span {
-                            ctx.diagnostic(
-                                CheckedRequiresOnchangeOrReadonlyDiagnostic::ExclusiveCheckedAttribute(
-                                    checked_span,
-                                    default_checked_span,
-                                ),
-                            );
+                            ctx.diagnostic(exclusive_checked_attribute(
+                                checked_span,
+                                default_checked_span,
+                            ));
                         }
                     }
 
                     if !self.ignore_missing_properties && is_missing_property {
-                        ctx.diagnostic(
-                            CheckedRequiresOnchangeOrReadonlyDiagnostic::MissingProperty(
-                                checked_span,
-                            ),
-                        );
+                        ctx.diagnostic(missing_property(checked_span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/react/jsx_key.rs b/crates/oxc_linter/src/rules/react/jsx_key.rs
index be93eae7b4a4..43e81d8a0aac 100644
--- a/crates/oxc_linter/src/rules/react/jsx_key.rs
+++ b/crates/oxc_linter/src/rules/react/jsx_key.rs
@@ -2,34 +2,31 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeName, JSXElement, JSXFragment, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_span::{GetSpan, Span};
 
 use oxc_macros::declare_oxc_lint;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum JsxKeyDiagnostic {
-    #[error(r#"eslint-plugin-react(jsx-key): Missing "key" prop for element in array."#)]
-    #[diagnostic(severity(warning))]
-    MissingKeyPropForElementInArray(#[label] Span),
-
-    #[error(r#"eslint-plugin-react(jsx-key): Missing "key" prop for element in iterator."#)]
-    #[diagnostic(severity(warning), help(r#"Add a "key" prop to the element in the iterator (https://react.dev/learn/rendering-lists#keeping-list-items-in-order-with-key)."#))]
-    MissingKeyPropForElementInIterator(
-        #[label("Iterator starts here")] Span,
-        #[label("Element generated here")] Span,
-    ),
-
-    #[error(
-        r#"eslint-plugin-react(jsx-key): "key" prop must be placed before any `{{...spread}}`"#
-    )]
-    #[diagnostic(severity(warning), help("To avoid conflicting with React's new JSX transform: https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html"))]
-    KeyPropMustBePlacedBeforeSpread(#[label] Span),
+fn missing_key_prop_for_element_in_array(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        r#"eslint-plugin-react(jsx-key): Missing "key" prop for element in array."#,
+    )
+    .with_labels([span0.into()])
+}
+
+fn missing_key_prop_for_element_in_iterator(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(r#"eslint-plugin-react(jsx-key): Missing "key" prop for element in iterator."#)
+        .with_help(r#"Add a "key" prop to the element in the iterator (https://react.dev/learn/rendering-lists#keeping-list-items-in-order-with-key)."#)
+        .with_labels([LabeledSpan::new_with_span(Some("Iterator starts here".into()), span0), LabeledSpan::new_with_span(Some("Element generated here".into()), span1)])
+}
+
+fn key_prop_must_be_placed_before_spread(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(r#"eslint-plugin-react(jsx-key): "key" prop must be placed before any `{...spread}`"#)
+        .with_help("To avoid conflicting with React's new JSX transform: https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -153,7 +150,9 @@ fn is_in_array_or_iter<'a, 'b>(
 fn check_jsx_element<'a>(node: &AstNode<'a>, jsx_elem: &JSXElement<'a>, ctx: &LintContext<'a>) {
     if let Some(outer) = is_in_array_or_iter(node, ctx) {
         if !jsx_elem.opening_element.attributes.iter().any(|attr| {
-            let JSXAttributeItem::Attribute(attr) = attr else { return false };
+            let JSXAttributeItem::Attribute(attr) = attr else {
+                return false;
+            };
 
             let JSXAttributeName::Identifier(attr_ident) = &attr.name else {
                 return false;
@@ -172,7 +171,9 @@ fn check_jsx_element_is_key_before_spread<'a>(jsx_elem: &JSXElement<'a>, ctx: &L
     for (i, attr) in jsx_elem.opening_element.attributes.iter().enumerate() {
         match attr {
             JSXAttributeItem::Attribute(attr) => {
-                let JSXAttributeName::Identifier(ident) = &attr.name else { continue };
+                let JSXAttributeName::Identifier(ident) = &attr.name else {
+                    continue;
+                };
                 if ident.name == "key" {
                     key_idx_span = Some((i, attr.name.span()));
                 }
@@ -186,7 +187,7 @@ fn check_jsx_element_is_key_before_spread<'a>(jsx_elem: &JSXElement<'a>, ctx: &L
 
     if let (Some((key_idx, key_span)), Some(spread_idx)) = (key_idx_span, spread_idx) {
         if key_idx > spread_idx {
-            ctx.diagnostic(JsxKeyDiagnostic::KeyPropMustBePlacedBeforeSpread(key_span));
+            ctx.diagnostic(key_prop_must_be_placed_before_spread(key_span));
         }
     }
 }
@@ -197,12 +198,10 @@ fn check_jsx_fragment<'a>(node: &AstNode<'a>, fragment: &JSXFragment<'a>, ctx: &
     }
 }
 
-fn gen_diagnostic(span: Span, outer: &InsideArrayOrIterator) -> JsxKeyDiagnostic {
+fn gen_diagnostic(span: Span, outer: &InsideArrayOrIterator) -> OxcDiagnostic {
     match outer {
-        InsideArrayOrIterator::Array => JsxKeyDiagnostic::MissingKeyPropForElementInArray(span),
-        InsideArrayOrIterator::Iterator(v) => {
-            JsxKeyDiagnostic::MissingKeyPropForElementInIterator(*v, span)
-        }
+        InsideArrayOrIterator::Array => missing_key_prop_for_element_in_array(span),
+        InsideArrayOrIterator::Iterator(v) => missing_key_prop_for_element_in_iterator(*v, span),
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/react/jsx_no_comment_textnodes.rs b/crates/oxc_linter/src/rules/react/jsx_no_comment_textnodes.rs
index 11b1be45a348..dd8e598f6197 100644
--- a/crates/oxc_linter/src/rules/react/jsx_no_comment_textnodes.rs
+++ b/crates/oxc_linter/src/rules/react/jsx_no_comment_textnodes.rs
@@ -1,19 +1,16 @@
 use lazy_static::lazy_static;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{Atom, Span};
 use regex::Regex;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react(jsx-no-comment-textnodes): Comments inside children section of tag should be placed inside braces")]
-#[diagnostic(severity(warning))]
-struct JsxNoCommentTextnodesDiagnostic(#[label] pub Span);
+fn jsx_no_comment_textnodes_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(jsx-no-comment-textnodes): Comments inside children section of tag should be placed inside braces").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct JsxNoCommentTextnodes;
@@ -55,10 +52,12 @@ declare_oxc_lint!(
 
 impl Rule for JsxNoCommentTextnodes {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXText(jsx_text) = node.kind() else { return };
+        let AstKind::JSXText(jsx_text) = node.kind() else {
+            return;
+        };
 
         if control_patterns(&jsx_text.value) {
-            ctx.diagnostic(JsxNoCommentTextnodesDiagnostic(jsx_text.span));
+            ctx.diagnostic(jsx_no_comment_textnodes_diagnostic(jsx_text.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/react/jsx_no_duplicate_props.rs b/crates/oxc_linter/src/rules/react/jsx_no_duplicate_props.rs
index dd18b8eee163..e7ca592352db 100644
--- a/crates/oxc_linter/src/rules/react/jsx_no_duplicate_props.rs
+++ b/crates/oxc_linter/src/rules/react/jsx_no_duplicate_props.rs
@@ -2,25 +2,19 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{Atom, CompactStr, Span};
+use oxc_span::{Atom, Span};
 use rustc_hash::FxHashMap;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-react(jsx-no-duplicate-props): No duplicate props allowed. The prop \"{0}\" is duplicated."
-)]
-#[diagnostic(
-    severity(warning),
-    help("Remove one of the props, or rename them so each prop is distinct.")
-)]
-struct JsxNoDuplicatePropsDiagnostic(CompactStr, #[label] pub Span, #[label] pub Span);
+fn jsx_no_duplicate_props_diagnostic(x0: &str, span1: Span, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-react(jsx-no-duplicate-props): No duplicate props allowed. The prop \"{x0}\" is duplicated."))
+        .with_help("Remove one of the props, or rename them so each prop is distinct.")
+        .with_labels([span1.into(), span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct JsxNoDuplicateProps;
@@ -52,18 +46,24 @@ declare_oxc_lint!(
 
 impl Rule for JsxNoDuplicateProps {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::JSXOpeningElement(jsx_opening_elem) = node.kind() else { return };
+        let AstKind::JSXOpeningElement(jsx_opening_elem) = node.kind() else {
+            return;
+        };
 
         let mut props: FxHashMap<Atom, Span> = FxHashMap::default();
 
         for attr in &jsx_opening_elem.attributes {
-            let JSXAttributeItem::Attribute(jsx_attr) = attr else { continue };
+            let JSXAttributeItem::Attribute(jsx_attr) = attr else {
+                continue;
+            };
 
-            let JSXAttributeName::Identifier(ident) = &jsx_attr.name else { continue };
+            let JSXAttributeName::Identifier(ident) = &jsx_attr.name else {
+                continue;
+            };
 
             if let Some(old_span) = props.insert(ident.name.clone(), ident.span) {
-                ctx.diagnostic(JsxNoDuplicatePropsDiagnostic(
-                    ident.name.to_compact_str(),
+                ctx.diagnostic(jsx_no_duplicate_props_diagnostic(
+                    ident.name.as_str(),
                     old_span,
                     ident.span,
                 ));
diff --git a/crates/oxc_linter/src/rules/react/jsx_no_target_blank.rs b/crates/oxc_linter/src/rules/react/jsx_no_target_blank.rs
index 9e8c6ea347db..fea3ace460e7 100644
--- a/crates/oxc_linter/src/rules/react/jsx_no_target_blank.rs
+++ b/crates/oxc_linter/src/rules/react/jsx_no_target_blank.rs
@@ -5,29 +5,29 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{Atom, GetSpan, Span};
 use std::ops::Deref;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum JsxNoTargetBlankDiagnostic {
-    #[error("eslint-plugin-react(jsx-no-target-blank): Using target=`_blank` without rel=`noreferrer` (which implies rel=`noopener`) is a security risk in older browsers: see https://mathiasbynens.github.io/rel-noopener/#recommendations")]
-    #[diagnostic(severity(warning), help("add rel=`noreferrer` to the element"))]
-    TargetBlankWithoutNoreferrer(#[label] Span),
+fn target_blank_without_noreferrer(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(jsx-no-target-blank): Using target=`_blank` without rel=`noreferrer` (which implies rel=`noopener`) is a security risk in older browsers: see https://mathiasbynens.github.io/rel-noopener/#recommendations")
+.with_help("add rel=`noreferrer` to the element")
+.with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-react(jsx-no-target-blank): Using target=`_blank` without rel=`noreferrer` or rel=`noopener` (the former implies the latter and is preferred due to wider support) is a security risk: see https://mathiasbynens.github.io/rel-noopener/#recommendations")]
-    #[diagnostic(severity(warning), help("add rel=`noreferrer` or rel=`noopener` to the element"))]
-    TargetBlankWithoutNoopener(#[label] Span),
+fn target_blank_without_noopener(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(jsx-no-target-blank): Using target=`_blank` without rel=`noreferrer` or rel=`noopener` (the former implies the latter and is preferred due to wider support) is a security risk: see https://mathiasbynens.github.io/rel-noopener/#recommendations")
+.with_help("add rel=`noreferrer` or rel=`noopener` to the element")
+.with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-react(jsx-no-target-blank): all spread attributes are treated as if they contain an unsafe combination of props, unless specifically overridden by props after the last spread attribute prop.")]
-    #[diagnostic(severity(warning), help("add rel=`noreferrer` to the element"))]
-    ExplicitPropsInSpreadAttributes(#[label] Span),
+fn explicit_props_in_spread_attributes(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(jsx-no-target-blank): all spread attributes are treated as if they contain an unsafe combination of props, unless specifically overridden by props after the last spread attribute prop.")
+.with_help("add rel=`noreferrer` to the element")
+.with_labels([span0.into()])
 }
 
 #[derive(Debug, Clone)]
@@ -60,9 +60,9 @@ impl Default for JsxNoTargetBlank {
 impl JsxNoTargetBlank {
     fn diagnostic(&self, span: Span, ctx: &LintContext) {
         if self.allow_referrer {
-            ctx.diagnostic(JsxNoTargetBlankDiagnostic::TargetBlankWithoutNoopener(span));
+            ctx.diagnostic(target_blank_without_noopener(span));
         } else {
-            ctx.diagnostic(JsxNoTargetBlankDiagnostic::TargetBlankWithoutNoreferrer(span));
+            ctx.diagnostic(target_blank_without_noreferrer(span));
         }
     }
     fn check_is_link(&self, tag_name: &str, ctx: &LintContext) -> bool {
@@ -185,11 +185,7 @@ impl Rule for JsxNoTargetBlank {
                         if (has_href_value && is_href_valid) || rel_valid_tuple.0 {
                             return;
                         }
-                        ctx.diagnostic(
-                            JsxNoTargetBlankDiagnostic::ExplicitPropsInSpreadAttributes(
-                                spread_span,
-                            ),
-                        );
+                        ctx.diagnostic(explicit_props_in_spread_attributes(spread_span));
                         return;
                     }
 
@@ -227,7 +223,6 @@ impl Rule for JsxNoTargetBlank {
                         EnforceDynamicLinksEnum::Never
                     }
                 }),
-
             warn_on_spread_attributes: value
                 .and_then(|val| {
                     val.get("warnOnSpreadAttributes").and_then(serde_json::Value::as_bool)
diff --git a/crates/oxc_linter/src/rules/react/jsx_no_undef.rs b/crates/oxc_linter/src/rules/react/jsx_no_undef.rs
index 2244dcc41fa9..57314e880575 100644
--- a/crates/oxc_linter/src/rules/react/jsx_no_undef.rs
+++ b/crates/oxc_linter/src/rules/react/jsx_no_undef.rs
@@ -5,19 +5,20 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react(jsx-no-undef): Disallow undeclared variables in JSX")]
-#[diagnostic(severity(warning), help("'{0}' is not defined."))]
-struct JsxNoUndefDiagnostic(CompactStr, #[label] pub Span);
+fn jsx_no_undef_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-react(jsx-no-undef): Disallow undeclared variables in JSX",
+    )
+    .with_help(format!("'{x0}' is not defined."))
+    .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct JsxNoUndef;
@@ -69,7 +70,7 @@ impl Rule for JsxNoUndef {
                         return;
                     }
                 }
-                ctx.diagnostic(JsxNoUndefDiagnostic(ident.name.to_compact_str(), ident.span));
+                ctx.diagnostic(jsx_no_undef_diagnostic(ident.name.as_str(), ident.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/react/jsx_no_useless_fragment.rs b/crates/oxc_linter/src/rules/react/jsx_no_useless_fragment.rs
index 9ae16084e89f..f7ad7b90b694 100644
--- a/crates/oxc_linter/src/rules/react/jsx_no_useless_fragment.rs
+++ b/crates/oxc_linter/src/rules/react/jsx_no_useless_fragment.rs
@@ -5,24 +5,19 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNodeId;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum JsxNoUselessFragmentDiagnostic {
-    #[error("eslint-plugin-react(jsx-no-useless-fragment): Fragments should contain more than one child.")]
-    #[diagnostic(severity(warning))]
-    NeedsMoreChildren(#[label] Span),
-    #[error("eslint-plugin-react(jsx-no-useless-fragment): Passing a fragment to a HTML element is useless.")]
-    #[diagnostic(severity(warning))]
-    ChildOfHtmlElement(#[label] Span),
+fn needs_more_children(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(jsx-no-useless-fragment): Fragments should contain more than one child.").with_labels([span0.into()])
+}
+
+fn child_of_html_element(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(jsx-no-useless-fragment): Passing a fragment to a HTML element is useless.").with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -92,12 +87,12 @@ impl JsxNoUselessFragment {
             && !(self.allow_expressions && is_fragment_with_single_expression(&elem.children))
         {
             let span = elem.opening_element.span;
-            ctx.diagnostic(JsxNoUselessFragmentDiagnostic::NeedsMoreChildren(span));
+            ctx.diagnostic(needs_more_children(span));
         }
 
         if is_child_of_html_element(node, ctx) {
             let span = elem.opening_element.span;
-            ctx.diagnostic(JsxNoUselessFragmentDiagnostic::ChildOfHtmlElement(span));
+            ctx.diagnostic(child_of_html_element(span));
         }
     }
     fn check_fragment(&self, node: &AstNode, elem: &JSXFragment, ctx: &LintContext) {
@@ -106,21 +101,25 @@ impl JsxNoUselessFragment {
             && !(self.allow_expressions && is_fragment_with_single_expression(&elem.children))
         {
             let span = elem.opening_fragment.span;
-            ctx.diagnostic(JsxNoUselessFragmentDiagnostic::NeedsMoreChildren(span));
+            ctx.diagnostic(needs_more_children(span));
         }
 
         if is_child_of_html_element(node, ctx) {
             let span = elem.opening_fragment.span;
-            ctx.diagnostic(JsxNoUselessFragmentDiagnostic::ChildOfHtmlElement(span));
+            ctx.diagnostic(child_of_html_element(span));
         }
     }
 }
 
 fn jsx_elem_has_key_attr(elem: &JSXElement) -> bool {
     elem.opening_element.attributes.iter().any(|attr| {
-        let JSXAttributeItem::Attribute(attr) = attr else { return false };
+        let JSXAttributeItem::Attribute(attr) = attr else {
+            return false;
+        };
 
-        let JSXAttributeName::Identifier(ident) = &attr.name else { return false };
+        let JSXAttributeName::Identifier(ident) = &attr.name else {
+            return false;
+        };
 
         ident.name == "key"
     })
@@ -151,7 +150,9 @@ fn is_child_of_html_element(node: &AstNode, ctx: &LintContext) -> bool {
 }
 
 fn is_html_element(elem_name: &JSXElementName) -> bool {
-    let JSXElementName::Identifier(ident) = elem_name else { return false };
+    let JSXElementName::Identifier(ident) = elem_name else {
+        return false;
+    };
 
     ident.name.starts_with(char::is_lowercase)
 }
@@ -202,7 +203,9 @@ fn is_fragment_with_only_text_and_is_not_child<'a>(
     }
 
     if let Some(JSXChild::Text(_)) = node.first() {
-        let Some(parent) = ctx.nodes().parent_kind(id) else { return false };
+        let Some(parent) = ctx.nodes().parent_kind(id) else {
+            return false;
+        };
         return !matches!(parent, AstKind::JSXElement(_) | AstKind::JSXFragment(_));
     }
 
diff --git a/crates/oxc_linter/src/rules/react/no_children_prop.rs b/crates/oxc_linter/src/rules/react/no_children_prop.rs
index 42bcd530b498..72aefc43d3d5 100644
--- a/crates/oxc_linter/src/rules/react/no_children_prop.rs
+++ b/crates/oxc_linter/src/rules/react/no_children_prop.rs
@@ -2,22 +2,20 @@ use oxc_ast::{
     ast::{Argument, JSXAttributeItem, JSXAttributeName, ObjectPropertyKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, utils::is_create_element_call, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react(no-children-prop): Avoid passing children using a prop.")]
-#[diagnostic(
-    severity(warning),
-    help("The canonical way to pass children in React is to use JSX elements")
-)]
-struct NoChildrenPropDiagnostic(#[label] pub Span);
+fn no_children_prop_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-react(no-children-prop): Avoid passing children using a prop.",
+    )
+    .with_help("The canonical way to pass children in React is to use JSX elements")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoChildrenProp;
@@ -63,9 +61,11 @@ impl Rule for NoChildrenProp {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         match node.kind() {
             AstKind::JSXAttributeItem(JSXAttributeItem::Attribute(attr)) => {
-                let JSXAttributeName::Identifier(attr_ident) = &attr.name else { return };
+                let JSXAttributeName::Identifier(attr_ident) = &attr.name else {
+                    return;
+                };
                 if attr_ident.name == "children" {
-                    ctx.diagnostic(NoChildrenPropDiagnostic(attr_ident.span));
+                    ctx.diagnostic(no_children_prop_diagnostic(attr_ident.span));
                 }
             }
             AstKind::CallExpression(call_expr) => {
@@ -80,7 +80,7 @@ impl Rule for NoChildrenProp {
 
                             None
                         }) {
-                            ctx.diagnostic(NoChildrenPropDiagnostic(span));
+                            ctx.diagnostic(no_children_prop_diagnostic(span));
                         }
                     }
                 }
diff --git a/crates/oxc_linter/src/rules/react/no_danger.rs b/crates/oxc_linter/src/rules/react/no_danger.rs
index fe5c83238f8d..caa82ecebbca 100644
--- a/crates/oxc_linter/src/rules/react/no_danger.rs
+++ b/crates/oxc_linter/src/rules/react/no_danger.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Argument, JSXAttributeItem, ObjectPropertyKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::GetSpan;
 use oxc_span::Span;
@@ -17,10 +15,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react(no-danger): Do not use `dangerouslySetInnerHTML` prop")]
-#[diagnostic(severity(warning), help("`dangerouslySetInnerHTML` is a way to inject HTML into your React component. This is dangerous because it can easily lead to XSS vulnerabilities."))]
-struct NoDangerDiagnostic(#[label] pub Span);
+fn no_danger_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(no-danger): Do not use `dangerouslySetInnerHTML` prop")
+        .with_help("`dangerouslySetInnerHTML` is a way to inject HTML into your React component. This is dangerous because it can easily lead to XSS vulnerabilities.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDanger;
@@ -48,7 +47,7 @@ impl Rule for NoDanger {
                 if let Some(JSXAttributeItem::Attribute(prop)) =
                     has_jsx_prop(&jsx_elem.opening_element, "dangerouslySetInnerHTML")
                 {
-                    ctx.diagnostic(NoDangerDiagnostic(prop.name.span()));
+                    ctx.diagnostic(no_danger_diagnostic(prop.name.span()));
                 }
             }
             AstKind::CallExpression(call_expr) => {
@@ -56,15 +55,19 @@ impl Rule for NoDanger {
                     return;
                 }
 
-                let Some(props) = call_expr.arguments.get(1) else { return };
+                let Some(props) = call_expr.arguments.get(1) else {
+                    return;
+                };
 
-                let Argument::ObjectExpression(obj_expr) = props else { return };
+                let Argument::ObjectExpression(obj_expr) = props else {
+                    return;
+                };
 
                 for prop in &obj_expr.properties {
                     if let ObjectPropertyKind::ObjectProperty(obj_prop) = prop {
                         if let Some(prop_name) = obj_prop.key.static_name() {
                             if prop_name.as_str() == "dangerouslySetInnerHTML" {
-                                ctx.diagnostic(NoDangerDiagnostic(obj_prop.key.span()));
+                                ctx.diagnostic(no_danger_diagnostic(obj_prop.key.span()));
                             }
                         }
                     }
diff --git a/crates/oxc_linter/src/rules/react/no_direct_mutation_state.rs b/crates/oxc_linter/src/rules/react/no_direct_mutation_state.rs
index d6182348ad6f..ac4392c927a0 100644
--- a/crates/oxc_linter/src/rules/react/no_direct_mutation_state.rs
+++ b/crates/oxc_linter/src/rules/react/no_direct_mutation_state.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Expression, MethodDefinitionKind, SimpleAssignmentTarget, StaticMemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -16,13 +14,13 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react(no-direct-mutation-state): never mutate this.state directly.")]
-#[diagnostic(
-    severity(warning),
-    help("calling setState() afterwards may replace the mutation you made.")
-)]
-struct NoDirectMutationStateDiagnostic(#[label] pub Span);
+fn no_direct_mutation_state_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-react(no-direct-mutation-state): never mutate this.state directly.",
+    )
+    .with_help("calling setState() afterwards may replace the mutation you made.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDirectMutationState;
@@ -169,7 +167,7 @@ impl Rule for NoDirectMutationState {
                 if let Some(assignment) = assignment_expr.left.as_simple_assignment_target() {
                     if let Some(outer_member_expression) = get_outer_member_expression(assignment) {
                         if is_state_member_expression(outer_member_expression) {
-                            ctx.diagnostic(NoDirectMutationStateDiagnostic(
+                            ctx.diagnostic(no_direct_mutation_state_diagnostic(
                                 assignment_expr.left.span(),
                             ));
                         }
@@ -186,7 +184,7 @@ impl Rule for NoDirectMutationState {
                     get_outer_member_expression(&update_expr.argument)
                 {
                     if is_state_member_expression(outer_member_expression) {
-                        ctx.diagnostic(NoDirectMutationStateDiagnostic(update_expr.span));
+                        ctx.diagnostic(no_direct_mutation_state_diagnostic(update_expr.span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/react/no_find_dom_node.rs b/crates/oxc_linter/src/rules/react/no_find_dom_node.rs
index a5e88fb9d8dd..b2ad396d7950 100644
--- a/crates/oxc_linter/src/rules/react/no_find_dom_node.rs
+++ b/crates/oxc_linter/src/rules/react/no_find_dom_node.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react(no-find-dom-node): Unexpected call to `findDOMNode`.")]
-#[diagnostic(severity(warning), help("Replace `findDOMNode` with one of the alternatives documented at https://react.dev/reference/react-dom/findDOMNode#alternatives."))]
-struct NoFindDomNodeDiagnostic(#[label] pub Span);
+fn no_find_dom_node_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(no-find-dom-node): Unexpected call to `findDOMNode`.")
+        .with_help("Replace `findDOMNode` with one of the alternatives documented at https://react.dev/reference/react-dom/findDOMNode#alternatives.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoFindDomNode;
@@ -42,16 +41,20 @@ declare_oxc_lint!(
 
 impl Rule for NoFindDomNode {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
         if let Some(ident) = call_expr.callee.get_identifier_reference() {
             if ident.name == "findDOMNode" {
-                ctx.diagnostic(NoFindDomNodeDiagnostic(ident.span));
+                ctx.diagnostic(no_find_dom_node_diagnostic(ident.span));
             }
             return;
         }
 
-        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
         let member = member_expr.object();
         if !member.is_specific_id("React")
             && !member.is_specific_id("ReactDOM")
@@ -59,8 +62,10 @@ impl Rule for NoFindDomNode {
         {
             return;
         }
-        let Some((span, "findDOMNode")) = member_expr.static_property_info() else { return };
-        ctx.diagnostic(NoFindDomNodeDiagnostic(span));
+        let Some((span, "findDOMNode")) = member_expr.static_property_info() else {
+            return;
+        };
+        ctx.diagnostic(no_find_dom_node_diagnostic(span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/react/no_is_mounted.rs b/crates/oxc_linter/src/rules/react/no_is_mounted.rs
index 06895173872d..33628377d822 100644
--- a/crates/oxc_linter/src/rules/react/no_is_mounted.rs
+++ b/crates/oxc_linter/src/rules/react/no_is_mounted.rs
@@ -1,17 +1,16 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint(no-is-mounted): Do not use isMounted")]
-#[diagnostic(severity(warning), help("isMounted is on its way to being officially deprecated. You can use a _isMounted property to track the mounted status yourself."))]
-struct NoIsMountedDiagnostic(#[label] pub Span);
+fn no_is_mounted_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint(no-is-mounted): Do not use isMounted")
+        .with_help("isMounted is on its way to being officially deprecated. You can use a _isMounted property to track the mounted status yourself.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoIsMounted;
@@ -63,7 +62,7 @@ impl Rule for NoIsMounted {
                 ctx.nodes().kind(ancestor),
                 AstKind::ObjectProperty(_) | AstKind::MethodDefinition(_)
             ) {
-                ctx.diagnostic(NoIsMountedDiagnostic(call_expr.span));
+                ctx.diagnostic(no_is_mounted_diagnostic(call_expr.span));
                 break;
             }
         }
diff --git a/crates/oxc_linter/src/rules/react/no_render_return_value.rs b/crates/oxc_linter/src/rules/react/no_render_return_value.rs
index 0304bc664c64..c1a749366693 100644
--- a/crates/oxc_linter/src/rules/react/no_render_return_value.rs
+++ b/crates/oxc_linter/src/rules/react/no_render_return_value.rs
@@ -1,17 +1,16 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react(no-render-return-value): Do not depend on the return value from ReactDOM.render.")]
-#[diagnostic(severity(warning), help("Using the return value is a legacy feature."))]
-struct NoRenderReturnValueDiagnostic(#[label] pub Span);
+fn no_render_return_value_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(no-render-return-value): Do not depend on the return value from ReactDOM.render.")
+        .with_help("Using the return value is a legacy feature.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoRenderReturnValue;
@@ -38,9 +37,15 @@ declare_oxc_lint!(
 
 impl Rule for NoRenderReturnValue {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
-        let Some(member_expr) = call_expr.callee.as_member_expression() else { return };
-        let Expression::Identifier(ident) = member_expr.object() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
+        let Some(member_expr) = call_expr.callee.as_member_expression() else {
+            return;
+        };
+        let Expression::Identifier(ident) = member_expr.object() else {
+            return;
+        };
         if ident.name == "ReactDOM" {
             if let Some((property_span, property_name)) = member_expr.static_property_info() {
                 if property_name == "render" {
@@ -52,7 +57,7 @@ impl Rule for NoRenderReturnValue {
                                 | AstKind::ReturnStatement(_)
                                 | AstKind::AssignmentExpression(_)
                         ) {
-                            ctx.diagnostic(NoRenderReturnValueDiagnostic(
+                            ctx.diagnostic(no_render_return_value_diagnostic(
                                 ident.span.merge(&property_span),
                             ));
                         }
@@ -63,7 +68,7 @@ impl Rule for NoRenderReturnValue {
                                 ctx.nodes().kind(ctx.scopes().get_node_id(scope_id))
                             {
                                 if e.expression {
-                                    ctx.diagnostic(NoRenderReturnValueDiagnostic(
+                                    ctx.diagnostic(no_render_return_value_diagnostic(
                                         ident.span.merge(&property_span),
                                     ));
                                 }
diff --git a/crates/oxc_linter/src/rules/react/no_string_refs.rs b/crates/oxc_linter/src/rules/react/no_string_refs.rs
index a3fdfb55ac31..5920081ee6c1 100644
--- a/crates/oxc_linter/src/rules/react/no_string_refs.rs
+++ b/crates/oxc_linter/src/rules/react/no_string_refs.rs
@@ -5,10 +5,7 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -19,15 +16,14 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoStringRefsDiagnostic {
-    #[error("eslint-plugin-react(no-string-refs): Using this.refs is deprecated.")]
-    #[diagnostic(severity(warning), help("Using this.xxx instead of this.refs.xxx"))]
-    ThisRefsDeprecated(#[label] Span),
+fn this_refs_deprecated(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(no-string-refs): Using this.refs is deprecated.")
+        .with_help("Using this.xxx instead of this.refs.xxx")
+        .with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-react(no-string-refs): Using string literals in ref attributes is deprecated.")]
-    #[diagnostic(severity(warning), help("Using reference callback instead"))]
-    StringInRefDeprecated(#[label] Span),
+fn string_in_ref_deprecated(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(no-string-refs): Using string literals in ref attributes is deprecated.").with_help("Using reference callback instead").with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -84,7 +80,9 @@ fn contains_string_literal(
 }
 
 fn is_literal_ref_attribute(attr: &JSXAttribute, no_template_literals: bool) -> bool {
-    let JSXAttributeName::Identifier(attr_ident) = &attr.name else { return false };
+    let JSXAttributeName::Identifier(attr_ident) = &attr.name else {
+        return false;
+    };
     if attr_ident.name == "ref" {
         if let Some(attr_value) = &attr.value {
             return match attr_value {
@@ -111,7 +109,7 @@ impl Rule for NoStringRefs {
         match node.kind() {
             AstKind::JSXAttributeItem(JSXAttributeItem::Attribute(attr)) => {
                 if is_literal_ref_attribute(attr, self.no_template_literals) {
-                    ctx.diagnostic(NoStringRefsDiagnostic::StringInRefDeprecated(attr.span));
+                    ctx.diagnostic(string_in_ref_deprecated(attr.span));
                 }
             }
             AstKind::MemberExpression(member_expr) => {
@@ -120,7 +118,7 @@ impl Rule for NoStringRefs {
                     && (get_parent_es5_component(node, ctx).is_some()
                         || get_parent_es6_component(ctx).is_some())
                 {
-                    ctx.diagnostic(NoStringRefsDiagnostic::ThisRefsDeprecated(member_expr.span()));
+                    ctx.diagnostic(this_refs_deprecated(member_expr.span()));
                 }
             }
             _ => {}
diff --git a/crates/oxc_linter/src/rules/react/no_unescaped_entities.rs b/crates/oxc_linter/src/rules/react/no_unescaped_entities.rs
index 115af37c507b..8aea0d2434fe 100644
--- a/crates/oxc_linter/src/rules/react/no_unescaped_entities.rs
+++ b/crates/oxc_linter/src/rules/react/no_unescaped_entities.rs
@@ -1,18 +1,18 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::{phf_map, Map};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react(no-unescaped-entities): `{1}` can be escaped with {2}")]
-#[diagnostic(severity(warning))]
-struct NoUnescapedEntitiesDiagnostic(#[label] pub Span, pub char, pub String);
+fn no_unescaped_entities_diagnostic(span0: Span, x1: char, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-react(no-unescaped-entities): `{x1}` can be escaped with {x2}"
+    ))
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnescapedEntities;
@@ -53,13 +53,13 @@ impl Rule for NoUnescapedEntities {
             for (i, char) in source.char_indices() {
                 if let Some(escapes) = DEFAULTS.get(&char) {
                     #[allow(clippy::cast_possible_truncation)]
-                    ctx.diagnostic(NoUnescapedEntitiesDiagnostic(
+                    ctx.diagnostic(no_unescaped_entities_diagnostic(
                         Span::new(
                             jsx_text.span.start + i as u32,
                             jsx_text.span.start + i as u32 + 1,
                         ),
                         char,
-                        escapes.join(" or "),
+                        &escapes.join(" or "),
                     ));
                 }
             }
diff --git a/crates/oxc_linter/src/rules/react/no_unknown_property.rs b/crates/oxc_linter/src/rules/react/no_unknown_property.rs
index 504b06b35367..edc240764c58 100644
--- a/crates/oxc_linter/src/rules/react/no_unknown_property.rs
+++ b/crates/oxc_linter/src/rules/react/no_unknown_property.rs
@@ -4,10 +4,7 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeName, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use phf::{phf_map, phf_set, Map, Set};
@@ -18,20 +15,28 @@ use std::collections::hash_set::HashSet;
 
 use crate::{context::LintContext, rule::Rule, utils::get_jsx_attribute_name, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoUnknownPropertyDiagnostic {
-    #[error("eslint-plugin-react(no-unknown-property): Invalid property found")]
-    #[diagnostic(severity(warning), help("Property '{1}' is only allowed on: {2}"))]
-    InvalidPropOnTag(#[label] Span, String, String),
-    #[error("eslint-plugin-react(no-unknown-property): React does not recognize data-* props with uppercase characters on a DOM element")]
-    #[diagnostic(severity(warning), help("Use '{1}' instead"))]
-    DataLowercaseRequired(#[label] Span, String),
-    #[error("eslint-plugin-react(no-unknown-property): Unknown property found")]
-    #[diagnostic(severity(warning), help("Use '{1}' instead"))]
-    UnknownPropWithStandardName(#[label] Span, String),
-    #[error("eslint-plugin-react(no-unknown-property): Unknown property found")]
-    #[diagnostic(severity(warning), help("Remove unknown property"))]
-    UnknownProp(#[label] Span),
+fn invalid_prop_on_tag(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(no-unknown-property): Invalid property found")
+        .with_help(format!("Property '{x1}' is only allowed on: {x2}"))
+        .with_labels([span0.into()])
+}
+
+fn data_lowercase_required(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(no-unknown-property): React does not recognize data-* props with uppercase characters on a DOM element")
+        .with_help(format!("Use '{x1}' instead"))
+        .with_labels([span0.into()])
+}
+
+fn unknown_prop_with_standard_name(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(no-unknown-property): Unknown property found")
+        .with_help(format!("Use '{x1}' instead"))
+        .with_labels([span0.into()])
+}
+
+fn unknown_prop(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(no-unknown-property): Unknown property found")
+        .with_help("Remove unknown property")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -485,10 +490,7 @@ impl Rule for NoUnknownProperty {
                 };
                 if is_valid_data_attr(actual_name.as_str()) {
                     if self.0.require_data_lowercase && has_uppercase(actual_name.as_str()) {
-                        ctx.diagnostic(NoUnknownPropertyDiagnostic::DataLowercaseRequired(
-                            span,
-                            actual_name.to_lowercase(),
-                        ));
+                        ctx.diagnostic(data_lowercase_required(span, &actual_name.to_lowercase()));
                     }
                     return;
                 };
@@ -498,10 +500,10 @@ impl Rule for NoUnknownProperty {
                 let name = normalize_attribute_case(actual_name.as_str());
                 if let Some(tags) = ATTRIBUTE_TAGS_MAP.get(name) {
                     if !tags.contains(el_type) {
-                        ctx.diagnostic(NoUnknownPropertyDiagnostic::InvalidPropOnTag(
+                        ctx.diagnostic(invalid_prop_on_tag(
                             span,
-                            actual_name.to_string(),
-                            tags.iter().join(", "),
+                            &actual_name,
+                            &tags.iter().join(", "),
                         ));
                     }
                     return;
@@ -516,15 +518,10 @@ impl Rule for NoUnknownProperty {
                     .or_else(|| DOM_ATTRIBUTES_TO_CAMEL.get(name))
                     .map_or_else(
                         || {
-                            ctx.diagnostic(NoUnknownPropertyDiagnostic::UnknownProp(span));
+                            ctx.diagnostic(unknown_prop(span));
                         },
                         |prop| {
-                            ctx.diagnostic(
-                                NoUnknownPropertyDiagnostic::UnknownPropWithStandardName(
-                                    span,
-                                    (*prop).to_string(),
-                                ),
-                            );
+                            ctx.diagnostic(unknown_prop_with_standard_name(span, prop));
                         },
                     );
             });
diff --git a/crates/oxc_linter/src/rules/react/react_in_jsx_scope.rs b/crates/oxc_linter/src/rules/react/react_in_jsx_scope.rs
index 6b31311a3829..c85994ee6959 100644
--- a/crates/oxc_linter/src/rules/react/react_in_jsx_scope.rs
+++ b/crates/oxc_linter/src/rules/react/react_in_jsx_scope.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{Atom, GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react(react-in-jsx-scope): 'React' must be in scope when using JSX")]
-#[diagnostic(severity(warning), help("When using JSX, `<a />` expands to `React.createElement(\"a\")`. Therefore the `React` variable must be in scope."))]
-struct ReactInJsxScopeDiagnostic(#[label] pub Span);
+fn react_in_jsx_scope_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(react-in-jsx-scope): 'React' must be in scope when using JSX")
+        .with_help("When using JSX, `<a />` expands to `React.createElement(\"a\")`. Therefore the `React` variable must be in scope.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ReactInJsxScope;
@@ -56,7 +55,7 @@ impl Rule for ReactInJsxScope {
             .ancestors(node.scope_id())
             .any(|v| scope.get_bindings(v).iter().any(|(k, _)| k == react_name))
         {
-            ctx.diagnostic(ReactInJsxScopeDiagnostic(node_span));
+            ctx.diagnostic(react_in_jsx_scope_diagnostic(node_span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/react/require_render_return.rs b/crates/oxc_linter/src/rules/react/require_render_return.rs
index fa2e479b2f75..1e4ef612b554 100644
--- a/crates/oxc_linter/src/rules/react/require_render_return.rs
+++ b/crates/oxc_linter/src/rules/react/require_render_return.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Argument, ClassElement, Expression, FunctionBody, ObjectPropertyKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -19,12 +17,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-react(require-render-return): Your render method should have a return statement"
-)]
-#[diagnostic(severity(warning), help("When writing the `render` method in a component it is easy to forget to return the JSX content. This rule will warn if the return statement is missing."))]
-struct RequireRenderReturnDiagnostic(#[label] pub Span);
+fn require_render_return_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(require-render-return): Your render method should have a return statement")
+        .with_help("When writing the `render` method in a component it is easy to forget to return the JSX content. This rule will warn if the return statement is missing.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct RequireRenderReturn;
@@ -85,7 +82,7 @@ impl Rule for RequireRenderReturn {
                         return;
                     }
 
-                    ctx.diagnostic(RequireRenderReturnDiagnostic(fn_body.span));
+                    ctx.diagnostic(require_render_return_diagnostic(fn_body.span));
                 }
             }
             AstKind::CallExpression(ce) => {
@@ -107,7 +104,7 @@ impl Rule for RequireRenderReturn {
                         })
                         .find(|fn_body| !has_return_in_fn_body(fn_body))
                     {
-                        ctx.diagnostic(RequireRenderReturnDiagnostic(fn_body.span));
+                        ctx.diagnostic(require_render_return_diagnostic(fn_body.span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/react/void_dom_elements_no_children.rs b/crates/oxc_linter/src/rules/react/void_dom_elements_no_children.rs
index 931c47684410..eb4ac7f88ab2 100644
--- a/crates/oxc_linter/src/rules/react/void_dom_elements_no_children.rs
+++ b/crates/oxc_linter/src/rules/react/void_dom_elements_no_children.rs
@@ -5,20 +5,19 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use phf::phf_set;
 
 use crate::{context::LintContext, rule::Rule, utils::is_create_element_call, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react(void-dom-elements-no-children): Disallow void DOM elements (e.g. `<img />`, `<br />`) from receiving children.")]
-#[diagnostic(severity(warning), help("Void DOM element <{0:?} /> cannot receive children."))]
-struct VoidDomElementsNoChildrenDiagnostic(pub String, #[label] pub Span);
+fn void_dom_elements_no_children_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react(void-dom-elements-no-children): Disallow void DOM elements (e.g. `<img />`, `<br />`) from receiving children.")
+        .with_help(format!("Void DOM element <{x0:?} /> cannot receive children."))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct VoidDomElementsNoChildren;
@@ -84,8 +83,8 @@ impl Rule for VoidDomElementsNoChildren {
                     });
 
                 if !jsx_el.children.is_empty() || has_children_attribute_or_danger {
-                    ctx.diagnostic(VoidDomElementsNoChildrenDiagnostic(
-                        identifier.name.to_string(),
+                    ctx.diagnostic(void_dom_elements_no_children_diagnostic(
+                        &identifier.name,
                         identifier.span,
                     ));
                 }
@@ -128,8 +127,8 @@ impl Rule for VoidDomElementsNoChildren {
                     });
 
                 if call_expr.arguments.get(2).is_some() || has_children_prop_or_danger {
-                    ctx.diagnostic(VoidDomElementsNoChildrenDiagnostic(
-                        element_name.value.to_string(),
+                    ctx.diagnostic(void_dom_elements_no_children_diagnostic(
+                        &element_name.value,
                         element_name.span,
                     ));
                 }
diff --git a/crates/oxc_linter/src/rules/react_perf/jsx_no_jsx_as_prop.rs b/crates/oxc_linter/src/rules/react_perf/jsx_no_jsx_as_prop.rs
index 852d1290804e..0f793f26859c 100644
--- a/crates/oxc_linter/src/rules/react_perf/jsx_no_jsx_as_prop.rs
+++ b/crates/oxc_linter/src/rules/react_perf/jsx_no_jsx_as_prop.rs
@@ -2,21 +2,18 @@ use oxc_ast::{
     ast::{Expression, JSXAttributeValue, JSXElement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, utils::get_prop_value, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-react-perf(jsx-no-jsx-as-prop): JSX attribute values should not contain other JSX."
-)]
-#[diagnostic(severity(warning), help(r"simplify props or memoize props in the parent component (https://react.dev/reference/react/memo#my-component-rerenders-when-a-prop-is-an-object-or-array)."))]
-struct JsxNoJsxAsPropDiagnostic(#[label] pub Span);
+fn jsx_no_jsx_as_prop_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react-perf(jsx-no-jsx-as-prop): JSX attribute values should not contain other JSX.")
+        .with_help(r"simplify props or memoize props in the parent component (https://react.dev/reference/react/memo#my-component-rerenders-when-a-prop-is-an-object-or-array).")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct JsxNoJsxAsProp;
@@ -55,7 +52,7 @@ fn check_jsx_element<'a>(jsx_elem: &JSXElement<'a>, ctx: &LintContext<'a>) {
             Some(JSXAttributeValue::ExpressionContainer(container)) => {
                 if let Some(expr) = container.expression.as_expression() {
                     if let Some(span) = check_expression(expr) {
-                        ctx.diagnostic(JsxNoJsxAsPropDiagnostic(span));
+                        ctx.diagnostic(jsx_no_jsx_as_prop_diagnostic(span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/react_perf/jsx_no_new_array_as_prop.rs b/crates/oxc_linter/src/rules/react_perf/jsx_no_new_array_as_prop.rs
index c3be839b4030..ba5071378764 100644
--- a/crates/oxc_linter/src/rules/react_perf/jsx_no_new_array_as_prop.rs
+++ b/crates/oxc_linter/src/rules/react_perf/jsx_no_new_array_as_prop.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Expression, JSXAttributeValue, JSXElement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,10 +14,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react-perf(jsx-no-new-array-as-prop): JSX attribute values should not contain Arrays created in the same scope.")]
-#[diagnostic(severity(warning), help(r"simplify props or memoize props in the parent component (https://react.dev/reference/react/memo#my-component-rerenders-when-a-prop-is-an-object-or-array)."))]
-struct JsxNoNewArrayAsPropDiagnostic(#[label] pub Span);
+fn jsx_no_new_array_as_prop_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react-perf(jsx-no-new-array-as-prop): JSX attribute values should not contain Arrays created in the same scope.")
+        .with_help(r"simplify props or memoize props in the parent component (https://react.dev/reference/react/memo#my-component-rerenders-when-a-prop-is-an-object-or-array).")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct JsxNoNewArrayAsProp;
@@ -61,7 +60,7 @@ fn check_jsx_element<'a>(jsx_elem: &JSXElement<'a>, ctx: &LintContext<'a>) {
             Some(JSXAttributeValue::ExpressionContainer(container)) => {
                 if let Some(expr) = container.expression.as_expression() {
                     if let Some(span) = check_expression(expr) {
-                        ctx.diagnostic(JsxNoNewArrayAsPropDiagnostic(span));
+                        ctx.diagnostic(jsx_no_new_array_as_prop_diagnostic(span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/react_perf/jsx_no_new_function_as_prop.rs b/crates/oxc_linter/src/rules/react_perf/jsx_no_new_function_as_prop.rs
index c6a9348e7062..0ef5419cca46 100644
--- a/crates/oxc_linter/src/rules/react_perf/jsx_no_new_function_as_prop.rs
+++ b/crates/oxc_linter/src/rules/react_perf/jsx_no_new_function_as_prop.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Expression, JSXAttributeValue, JSXElement, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,10 +14,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react-perf(jsx-no-new-function-as-prop): JSX attribute values should not contain functions created in the same scope.")]
-#[diagnostic(severity(warning), help(r"simplify props or memoize props in the parent component (https://react.dev/reference/react/memo#my-component-rerenders-when-a-prop-is-an-object-or-array)."))]
-struct JsxNoNewFunctionAsPropDiagnostic(#[label] pub Span);
+fn jsx_no_new_function_as_prop_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react-perf(jsx-no-new-function-as-prop): JSX attribute values should not contain functions created in the same scope.")
+        .with_help(r"simplify props or memoize props in the parent component (https://react.dev/reference/react/memo#my-component-rerenders-when-a-prop-is-an-object-or-array).")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct JsxNoNewFunctionAsProp;
@@ -56,7 +55,7 @@ fn check_jsx_element<'a>(jsx_elem: &JSXElement<'a>, ctx: &LintContext<'a>) {
             Some(JSXAttributeValue::ExpressionContainer(container)) => {
                 if let Some(expr) = container.expression.as_expression() {
                     if let Some(span) = check_expression(expr) {
-                        ctx.diagnostic(JsxNoNewFunctionAsPropDiagnostic(span));
+                        ctx.diagnostic(jsx_no_new_function_as_prop_diagnostic(span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/react_perf/jsx_no_new_object_as_prop.rs b/crates/oxc_linter/src/rules/react_perf/jsx_no_new_object_as_prop.rs
index 4af883a05899..62c82bcd7e99 100644
--- a/crates/oxc_linter/src/rules/react_perf/jsx_no_new_object_as_prop.rs
+++ b/crates/oxc_linter/src/rules/react_perf/jsx_no_new_object_as_prop.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Expression, JSXAttributeValue, JSXElement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -16,10 +14,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-react-perf(jsx-no-new-object-as-prop): JSX attribute values should not contain objects created in the same scope.")]
-#[diagnostic(severity(warning), help(r"simplify props or memoize props in the parent component (https://react.dev/reference/react/memo#my-component-rerenders-when-a-prop-is-an-object-or-array)."))]
-struct JsxNoNewObjectAsPropDiagnostic(#[label] pub Span);
+fn jsx_no_new_object_as_prop_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-react-perf(jsx-no-new-object-as-prop): JSX attribute values should not contain objects created in the same scope.")
+        .with_help(r"simplify props or memoize props in the parent component (https://react.dev/reference/react/memo#my-component-rerenders-when-a-prop-is-an-object-or-array).")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct JsxNoNewObjectAsProp;
@@ -60,7 +59,7 @@ fn check_jsx_element<'a>(jsx_elem: &JSXElement<'a>, ctx: &LintContext<'a>) {
             Some(JSXAttributeValue::ExpressionContainer(container)) => {
                 if let Some(expr) = container.expression.as_expression() {
                     if let Some(span) = check_expression(expr) {
-                        ctx.diagnostic(JsxNoNewObjectAsPropDiagnostic(span));
+                        ctx.diagnostic(jsx_no_new_object_as_prop_diagnostic(span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/tree_shaking/no_side_effects_in_initialization/listener_map.rs b/crates/oxc_linter/src/rules/tree_shaking/no_side_effects_in_initialization/listener_map.rs
index 3b2f786ae628..0ea05dbc8606 100644
--- a/crates/oxc_linter/src/rules/tree_shaking/no_side_effects_in_initialization/listener_map.rs
+++ b/crates/oxc_linter/src/rules/tree_shaking/no_side_effects_in_initialization/listener_map.rs
@@ -31,7 +31,6 @@ use crate::{
     LintContext,
 };
 
-use super::NoSideEffectsDiagnostic;
 pub struct NodeListenerOptions<'a, 'b> {
     checked_mutated_nodes: RefCell<FxHashSet<SymbolId>>,
     ctx: &'b LintContext<'a>,
@@ -118,7 +117,7 @@ impl<'a> ListenerMap for Statement<'a> {
                 });
             }
             Self::ThrowStatement(stmt) => {
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::Throw(stmt.span));
+                options.ctx.diagnostic(super::throw(stmt.span));
             }
             Self::BlockStatement(stmt) => {
                 stmt.body.iter().for_each(|stmt| stmt.report_effects(options));
@@ -153,7 +152,7 @@ impl<'a> ListenerMap for Statement<'a> {
                 stmt.body.report_effects(options);
             }
             Self::DebuggerStatement(stmt) => {
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::Debugger(stmt.span));
+                options.ctx.diagnostic(super::debugger(stmt.span));
             }
             Self::ForStatement(stmt) => {
                 if let Some(init) = &stmt.init {
@@ -260,14 +259,12 @@ impl<'a> ListenerMap for AstNode<'a> {
                 }
             }
             AstKind::FormalParameter(param) => {
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::CallParameter(param.span));
+                options.ctx.diagnostic(super::call_parameter(param.span));
             }
             AstKind::BindingRestElement(rest) => {
                 let start = rest.span.start + 3;
                 let end = rest.span.end;
-                options
-                    .ctx
-                    .diagnostic(NoSideEffectsDiagnostic::CallParameter(Span::new(start, end)));
+                options.ctx.diagnostic(super::call_parameter(Span::new(start, end)));
             }
             AstKind::Function(function) => {
                 let old_val = options.has_valid_this.get();
@@ -280,19 +277,19 @@ impl<'a> ListenerMap for AstNode<'a> {
             }
             AstKind::ImportDefaultSpecifier(specifier) => {
                 if !has_comment_about_side_effect_check(specifier.span, options.ctx) {
-                    options.ctx.diagnostic(NoSideEffectsDiagnostic::CallImport(specifier.span));
+                    options.ctx.diagnostic(super::call_import(specifier.span));
                 }
             }
             AstKind::ImportSpecifier(specifier) => {
                 let span = specifier.local.span;
                 if !has_comment_about_side_effect_check(span, options.ctx) {
-                    options.ctx.diagnostic(NoSideEffectsDiagnostic::CallImport(span));
+                    options.ctx.diagnostic(super::call_import(span));
                 }
             }
             AstKind::ImportNamespaceSpecifier(specifier) => {
                 let span = specifier.local.span;
                 if !has_comment_about_side_effect_check(span, options.ctx) {
-                    options.ctx.diagnostic(NoSideEffectsDiagnostic::CallImport(span));
+                    options.ctx.diagnostic(super::call_import(span));
                 }
             }
             _ => {}
@@ -306,23 +303,21 @@ impl<'a> ListenerMap for AstNode<'a> {
                 }
             }
             AstKind::FormalParameter(param) => {
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::MutateParameter(param.span));
+                options.ctx.diagnostic(super::mutate_parameter(param.span));
             }
             AstKind::BindingRestElement(rest) => {
                 let start = rest.span.start + 3;
                 let end = rest.span.end;
-                options
-                    .ctx
-                    .diagnostic(NoSideEffectsDiagnostic::MutateParameter(Span::new(start, end)));
+                options.ctx.diagnostic(super::mutate_parameter(Span::new(start, end)));
             }
             AstKind::ImportDefaultSpecifier(specifier) => {
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::MutateImport(specifier.span));
+                options.ctx.diagnostic(super::mutate_import(specifier.span));
             }
             AstKind::ImportSpecifier(specifier) => {
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::MutateImport(specifier.local.span));
+                options.ctx.diagnostic(super::mutate_import(specifier.local.span));
             }
             AstKind::ImportNamespaceSpecifier(specifier) => {
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::MutateImport(specifier.local.span));
+                options.ctx.diagnostic(super::mutate_import(specifier.local.span));
             }
             _ => {}
         }
@@ -596,7 +591,7 @@ impl<'a> ListenerMap for Expression<'a> {
             }
             _ => {
                 // Default behavior
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::Mutate(self.span()));
+                options.ctx.diagnostic(super::mutate(self.span()));
             }
         }
     }
@@ -635,7 +630,7 @@ impl<'a> ListenerMap for Expression<'a> {
             }
             _ => {
                 // Default behavior
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::Call(self.span()));
+                options.ctx.diagnostic(super::call(self.span()));
             }
         }
     }
@@ -707,7 +702,7 @@ impl<'a> ListenerMap for UnaryExpression<'a> {
                 Expression::PrivateFieldExpression(expr) => {
                     expr.object.report_effects_when_mutated(options);
                 }
-                _ => options.ctx.diagnostic(NoSideEffectsDiagnostic::Delete(self.argument.span())),
+                _ => options.ctx.diagnostic(super::delete(self.argument.span())),
             }
             return Value::Unknown;
         }
@@ -805,10 +800,7 @@ impl<'a> ListenerMap for JSXIdentifier<'a> {
     fn report_effects_when_called(&self, options: &NodeListenerOptions) {
         if self.name.chars().next().is_some_and(char::is_uppercase) {
             let Some(symbol_id) = options.ctx.symbols().get_symbol_id_from_name(&self.name) else {
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::CallGlobal(
-                    self.name.to_compact_str(),
-                    self.span,
-                ));
+                options.ctx.diagnostic(super::call_global(self.name.as_str(), self.span));
                 return;
             };
 
@@ -986,7 +978,7 @@ impl<'a> ListenerMap for BinaryExpression<'a> {
 impl ListenerMap for ThisExpression {
     fn report_effects_when_mutated(&self, options: &NodeListenerOptions) {
         if !options.has_valid_this.get() {
-            options.ctx.diagnostic(NoSideEffectsDiagnostic::MutateOfThis(self.span));
+            options.ctx.diagnostic(super::mutate_of_this(self.span));
         }
     }
 }
@@ -1054,7 +1046,7 @@ impl<'a> ListenerMap for CallExpression<'a> {
             self.callee.report_effects_when_called(options);
             options.called_with_new.set(old_value);
         } else {
-            options.ctx.diagnostic(NoSideEffectsDiagnostic::Call(self.callee.span()));
+            options.ctx.diagnostic(super::call(self.callee.span()));
         }
     }
     fn report_effects_when_called(&self, options: &NodeListenerOptions) {
@@ -1068,14 +1060,14 @@ impl<'a> ListenerMap for CallExpression<'a> {
                 if matches!(parent, AstKind::ImportDeclaration(_)) {
                     return;
                 }
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::CallReturnValue(self.span));
+                options.ctx.diagnostic(super::call_return_value(self.span));
             } else {
-                options.ctx.diagnostic(NoSideEffectsDiagnostic::CallReturnValue(self.span));
+                options.ctx.diagnostic(super::call_return_value(self.span));
             }
         }
     }
     fn report_effects_when_mutated(&self, options: &NodeListenerOptions) {
-        options.ctx.diagnostic(NoSideEffectsDiagnostic::MutateFunctionReturnValue(self.span));
+        options.ctx.diagnostic(super::mutate_function_return_value(self.span));
     }
 }
 
@@ -1123,10 +1115,7 @@ impl<'a> ListenerMap for SimpleAssignmentTarget<'a> {
 impl<'a> ListenerMap for IdentifierReference<'a> {
     fn report_effects_when_assigned(&self, options: &NodeListenerOptions) {
         if get_symbol_id_of_variable(self, options.ctx).is_none() {
-            options.ctx.diagnostic(NoSideEffectsDiagnostic::Assignment(
-                self.name.to_compact_str(),
-                self.span,
-            ));
+            options.ctx.diagnostic(super::assignment(self.name.as_str(), self.span));
         }
     }
 
@@ -1150,10 +1139,7 @@ impl<'a> ListenerMap for IdentifierReference<'a> {
             let node = ctx.nodes().get_node(symbol_table.get_declaration(symbol_id));
             node.report_effects_when_called(options);
         } else {
-            ctx.diagnostic(NoSideEffectsDiagnostic::CallGlobal(
-                self.name.to_compact_str(),
-                self.span,
-            ));
+            ctx.diagnostic(super::call_global(self.name.as_str(), self.span));
         }
     }
 
@@ -1175,10 +1161,7 @@ impl<'a> ListenerMap for IdentifierReference<'a> {
                 node.report_effects_when_mutated(options);
             }
         } else {
-            ctx.diagnostic(NoSideEffectsDiagnostic::MutateWithName(
-                self.name.to_compact_str(),
-                self.span,
-            ));
+            ctx.diagnostic(super::mutate_with_name(self.name.as_str(), self.span));
         }
     }
 }
@@ -1250,7 +1233,7 @@ impl<'a> ListenerMap for ComputedMemberExpression<'a> {
         if let Expression::Identifier(ident) = node {
             ident.report_effects_when_called(options);
         } else {
-            options.ctx.diagnostic(NoSideEffectsDiagnostic::CallMember(node.span()));
+            options.ctx.diagnostic(super::call_member(node.span()));
         }
     }
     fn report_effects_when_assigned(&self, options: &NodeListenerOptions) {
@@ -1281,7 +1264,7 @@ impl<'a> ListenerMap for StaticMemberExpression<'a> {
         }
 
         let Expression::Identifier(ident) = node else {
-            options.ctx.diagnostic(NoSideEffectsDiagnostic::CallMember(node.span()));
+            options.ctx.diagnostic(super::call_member(node.span()));
             return;
         };
 
@@ -1289,7 +1272,7 @@ impl<'a> ListenerMap for StaticMemberExpression<'a> {
             .is_some_and(|_| !has_pure_notation(self.span, options.ctx))
             || !is_pure_function(&FunctionName::StaticMemberExpr(self), options.ctx)
         {
-            options.ctx.diagnostic(NoSideEffectsDiagnostic::CallMember(self.span));
+            options.ctx.diagnostic(super::call_member(self.span));
         }
     }
     fn report_effects_when_assigned(&self, options: &NodeListenerOptions) {
@@ -1322,7 +1305,7 @@ impl<'a> ListenerMap for PrivateFieldExpression<'a> {
         if let Expression::Identifier(ident) = node {
             ident.report_effects_when_called(options);
         } else {
-            options.ctx.diagnostic(NoSideEffectsDiagnostic::CallMember(node.span()));
+            options.ctx.diagnostic(super::call_member(node.span()));
         }
     }
     fn report_effects_when_assigned(&self, options: &NodeListenerOptions) {
diff --git a/crates/oxc_linter/src/rules/tree_shaking/no_side_effects_in_initialization/mod.rs b/crates/oxc_linter/src/rules/tree_shaking/no_side_effects_in_initialization/mod.rs
index 63e6bdd82949..bd4816198b6f 100644
--- a/crates/oxc_linter/src/rules/tree_shaking/no_side_effects_in_initialization/mod.rs
+++ b/crates/oxc_linter/src/rules/tree_shaking/no_side_effects_in_initialization/mod.rs
@@ -1,10 +1,7 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
 
@@ -12,71 +9,68 @@ use self::listener_map::{ListenerMap, NodeListenerOptions};
 
 mod listener_map;
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoSideEffectsDiagnostic {
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of assignment to `{0}`")]
-    #[diagnostic(severity(warning))]
-    Assignment(CompactStr, #[label] Span),
+fn assignment(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of assignment to `{x0}`")).with_labels([span1.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating")]
-    #[diagnostic(severity(warning))]
-    Mutate(#[label] Span),
+fn mutate(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating `{0}`")]
-    #[diagnostic(severity(warning))]
-    MutateWithName(CompactStr, #[label] Span),
+fn mutate_with_name(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating `{x0}`")).with_labels([span1.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating function return value")]
-    #[diagnostic(severity(warning))]
-    MutateFunctionReturnValue(#[label] Span),
+fn mutate_function_return_value(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating function return value").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating function parameter")]
-    #[diagnostic(severity(warning))]
-    MutateParameter(#[label] Span),
+fn mutate_parameter(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating function parameter").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating unknown this value")]
-    #[diagnostic(severity(warning))]
-    MutateOfThis(#[label] Span),
+fn mutate_of_this(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating unknown this value").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating imported variable")]
-    #[diagnostic(severity(warning))]
-    MutateImport(#[label] Span),
+fn mutate_import(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of mutating imported variable").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling")]
-    #[diagnostic(severity(warning))]
-    Call(#[label] Span),
+fn call(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling function return value")]
-    #[diagnostic(severity(warning))]
-    CallReturnValue(#[label] Span),
+fn call_return_value(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling function return value").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling global function `{0}`")]
-    #[diagnostic(severity(warning))]
-    CallGlobal(CompactStr, #[label] Span),
+fn call_global(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling global function `{x0}`")).with_labels([span1.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling function parameter")]
-    #[diagnostic(severity(warning))]
-    CallParameter(#[label] Span),
+fn call_parameter(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling function parameter").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling imported function")]
-    #[diagnostic(severity(warning))]
-    CallImport(#[label] Span),
+fn call_import(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling imported function").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling member function")]
-    #[diagnostic(severity(warning))]
-    CallMember(#[label] Span),
+fn call_member(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of calling member function").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Debugger statements are side-effects")]
-    #[diagnostic(severity(warning))]
-    Debugger(#[label] Span),
+fn debugger(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Debugger statements are side-effects").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of deleting anything but a MemberExpression")]
-    #[diagnostic(severity(warning))]
-    Delete(#[label] Span),
+fn delete(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Cannot determine side-effects of deleting anything but a MemberExpression").with_labels([span0.into()])
+}
 
-    #[error("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Throwing an error is a side-effect")]
-    #[diagnostic(severity(warning))]
-    Throw(#[label] Span),
+fn throw(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-tree-shaking(no-side-effects-in-initialization): Throwing an error is a side-effect").with_labels([span0.into()])
 }
 
 /// <https://github.com/lukastaegert/eslint-plugin-tree-shaking/blob/master/src/rules/no-side-effects-in-initialization.ts>
@@ -106,7 +100,9 @@ declare_oxc_lint!(
 
 impl Rule for NoSideEffectsInInitialization {
     fn run_once(&self, ctx: &LintContext) {
-        let Some(root) = ctx.nodes().root_node() else { return };
+        let Some(root) = ctx.nodes().root_node() else {
+            return;
+        };
         let AstKind::Program(program) = root.kind() else { unreachable!() };
         let node_listener_options = NodeListenerOptions::new(ctx);
         program.report_effects(&node_listener_options);
@@ -671,7 +667,7 @@ fn test() {
         // YieldExpression
         "function* x(){yield ext()}; x()",
         // YieldExpression when called
-        "function* x(){yield ext()}; x()"
+        "function* x(){yield ext()}; x()",
     ];
 
     Tester::new(NoSideEffectsInInitialization::NAME, pass, fail).test_and_snapshot();
diff --git a/crates/oxc_linter/src/rules/typescript/adjacent_overload_signatures.rs b/crates/oxc_linter/src/rules/typescript/adjacent_overload_signatures.rs
index 09166515efb2..bfe7e682057e 100644
--- a/crates/oxc_linter/src/rules/typescript/adjacent_overload_signatures.rs
+++ b/crates/oxc_linter/src/rules/typescript/adjacent_overload_signatures.rs
@@ -5,25 +5,24 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{CompactStr, GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "typescript-eslint(adjacent-overload-signatures): All {0:?} signatures should be adjacent."
-)]
-#[diagnostic(severity(warning))]
-struct AdjacentOverloadSignaturesDiagnostic(
-    CompactStr,
-    #[label] pub Option<Span>,
-    #[label] pub Span,
-);
+fn adjacent_overload_signatures_diagnostic(
+    x0: &str,
+    span1: Option<Span>,
+    span2: Span,
+) -> OxcDiagnostic {
+    let mut d = OxcDiagnostic::warning(format!("typescript-eslint(adjacent-overload-signatures): All {x0:?} signatures should be adjacent."));
+    if let Some(span) = span1 {
+        d = d.and_label(span);
+    }
+    d.and_label(span2)
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct AdjacentOverloadSignatures;
@@ -258,16 +257,16 @@ fn check_and_report(methods: &Vec<Option<Method>>, ctx: &LintContext<'_>) {
 
             if index.is_some() && !method.is_same_method(last_method) {
                 let name = if method.r#static {
-                    CompactStr::from(format!("static {0}", method.name))
+                    format!("static {0}", method.name)
                 } else {
-                    method.name.clone()
+                    method.name.to_string()
                 };
 
                 let last_same_method =
                     seen_methods.iter().rev().find(|m| m.is_same_method(Some(method)));
 
-                ctx.diagnostic(AdjacentOverloadSignaturesDiagnostic(
-                    name,
+                ctx.diagnostic(adjacent_overload_signatures_diagnostic(
+                    &name,
                     last_same_method.map(|m| m.span),
                     method.span,
                 ));
diff --git a/crates/oxc_linter/src/rules/typescript/array_type.rs b/crates/oxc_linter/src/rules/typescript/array_type.rs
index 57ab112e0c83..332a08c44126 100644
--- a/crates/oxc_linter/src/rules/typescript/array_type.rs
+++ b/crates/oxc_linter/src/rules/typescript/array_type.rs
@@ -2,10 +2,7 @@ use oxc_ast::{
     ast::{TSType, TSTypeName, TSTypeOperatorOperator, TSTypeReference},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNode;
 use oxc_span::Span;
@@ -31,29 +28,20 @@ declare_oxc_lint!(
     style,
 );
 
-#[derive(Debug, Diagnostic, Error)]
-pub enum ArrayTypeDiagnostic {
-    #[error("typescript-eslint(array-type): Array type using '{0}{2}[]' is forbidden. Use '{1}<{2}>' instead.")]
-    #[diagnostic(severity(warning))]
-    // readonlyPrefix className type
-    Generic(String, String, String, #[label] Span),
+fn generic(x0: &str, x1: &str, x2: &str, span3: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("typescript-eslint(array-type): Array type using '{x0}{x2}[]' is forbidden. Use '{x1}<{x2}>' instead.")).with_labels([span3.into()])
+}
 
-    #[error(
-        "typescript-eslint(array-type): Array type using '{0}{2}[]' is forbidden for non-simple types. Use '{1}<{2}>' instead."
-    )]
-    #[diagnostic(severity(warning))]
-    // readonlyPrefix className type
-    GenericSimple(String, String, String, #[label] Span),
+fn generic_simple(x0: &str, x1: &str, x2: &str, span3: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("typescript-eslint(array-type): Array type using '{x0}{x2}[]' is forbidden for non-simple types. Use '{x1}<{x2}>' instead.")).with_labels([span3.into()])
+}
 
-    #[error("typescript-eslint(array-type): Array type using '{1}<{2}>' is forbidden. Use '{0}{2}[]' instead.")]
-    #[diagnostic(severity(warning))]
-    // readonlyPrefix className type
-    Array(String, String, String, #[label] Span),
+fn array(x0: &str, x1: &str, x2: &str, span3: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("typescript-eslint(array-type): Array type using '{x1}<{x2}>' is forbidden. Use '{x0}{x2}[]' instead.")).with_labels([span3.into()])
+}
 
-    #[error("typescript-eslint(array-type): Array type using '{1}<{2}>' is forbidden for simple types. Use '{0}{2}[]' instead.")]
-    #[diagnostic(severity(warning))]
-    // readonlyPrefix className type
-    ArraySimple(String, String, String, #[label] Span),
+fn array_simple(x0: &str, x1: &str, x2: &str, span3: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("typescript-eslint(array-type): Array type using '{x1}<{x2}>' is forbidden for simple types. Use '{x0}{x2}[]' instead.")).with_labels([span3.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -204,21 +192,15 @@ fn check_and_report_error_generic(
     let message_type = get_message_type(type_param, &source_text);
 
     let diagnostic = match config {
-        ArrayOption::Generic => ArrayTypeDiagnostic::Generic(
-            readonly_prefix.to_string(),
-            class_name.to_string(),
-            message_type.to_string(),
-            type_reference_span,
-        ),
-        _ => ArrayTypeDiagnostic::GenericSimple(
-            readonly_prefix.to_string(),
-            class_name.to_string(),
-            message_type.to_string(),
-            type_reference_span,
-        ),
+        ArrayOption::Generic => {
+            generic(readonly_prefix, class_name, message_type, type_reference_span)
+        }
+        _ => generic_simple(readonly_prefix, class_name, message_type, type_reference_span),
     };
     let element_type_span = get_ts_element_type_span(type_param);
-    let Some(element_type_span) = element_type_span else { return };
+    let Some(element_type_span) = element_type_span else {
+        return;
+    };
 
     ctx.diagnostic_with_fix(diagnostic, || {
         let type_text =
@@ -258,16 +240,11 @@ fn check_and_report_error_array(
 
     if type_params.is_none() || type_params.as_ref().unwrap().params.len() == 0 {
         let diagnostic = match config {
-            ArrayOption::Array => ArrayTypeDiagnostic::Array(
-                readonly_prefix.to_string(),
-                class_name.to_string(),
-                "any".to_string(),
-                ts_type_reference.span,
-            ),
-            _ => ArrayTypeDiagnostic::ArraySimple(
-                readonly_prefix.to_string(),
-                ident_ref_type_name.name.to_string(),
-                "any".to_string(),
+            ArrayOption::Array => array(readonly_prefix, class_name, "any", ts_type_reference.span),
+            _ => array_simple(
+                readonly_prefix,
+                &ident_ref_type_name.name,
+                "any",
                 ts_type_reference.span,
             ),
         };
@@ -295,7 +272,9 @@ fn check_and_report_error_array(
     let parent_parens = false;
 
     let element_type_span = get_ts_element_type_span(first_type_param);
-    let Some(element_type_span) = element_type_span else { return };
+    let Some(element_type_span) = element_type_span else {
+        return;
+    };
 
     let type_text =
         &ctx.source_text()[element_type_span.start as usize..element_type_span.end as usize];
@@ -310,16 +289,13 @@ fn check_and_report_error_array(
 
     let message_type = get_message_type(first_type_param, ctx.source_text());
     let diagnostic = match config {
-        ArrayOption::Array => ArrayTypeDiagnostic::Array(
-            readonly_prefix.to_string(),
-            class_name.to_string(),
-            message_type.to_string(),
-            ts_type_reference.span,
-        ),
-        _ => ArrayTypeDiagnostic::ArraySimple(
-            readonly_prefix.to_string(),
-            ident_ref_type_name.name.to_string(),
-            message_type.to_string(),
+        ArrayOption::Array => {
+            array(readonly_prefix, class_name, message_type, ts_type_reference.span)
+        }
+        _ => array_simple(
+            readonly_prefix,
+            &ident_ref_type_name.name,
+            message_type,
             ts_type_reference.span,
         ),
     };
@@ -376,7 +352,9 @@ fn is_simple_type(ts_type: &TSType) -> bool {
 fn get_message_type<'a>(type_param: &'a TSType, source_text: &'a str) -> &'a str {
     if is_simple_type(type_param) {
         let element_type_span = get_ts_element_type_span(type_param);
-        let Some(element_type_span) = element_type_span else { return "T" };
+        let Some(element_type_span) = element_type_span else {
+            return "T";
+        };
         return &source_text[element_type_span.start as usize..element_type_span.end as usize];
     }
     "T"
diff --git a/crates/oxc_linter/src/rules/typescript/ban_ts_comment.rs b/crates/oxc_linter/src/rules/typescript/ban_ts_comment.rs
index dab6862bdc43..74b819098f2c 100644
--- a/crates/oxc_linter/src/rules/typescript/ban_ts_comment.rs
+++ b/crates/oxc_linter/src/rules/typescript/ban_ts_comment.rs
@@ -1,35 +1,30 @@
 use oxc_ast::CommentKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use regex::Regex;
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-pub enum BanTsCommentDiagnostic {
-    #[error(
-        "typescript-eslint(ban-ts-comment): Do not use @ts-{0} because it alters compilation errors."
-    )]
-    #[diagnostic(severity(warning))]
-    Comment(String, #[label] Span),
+fn comment(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("typescript-eslint(ban-ts-comment): Do not use @ts-{x0} because it alters compilation errors.")).with_labels([span1.into()])
+}
 
-    #[error(
-        "typescript-eslint(ban-ts-comment): Use \"@ts-expect-error\" instead of @ts-ignore, as \"@ts-ignore\" will do nothing if the following line is error-free."
-    )]
-    #[diagnostic(severity(warning), help("Replace \"@ts-ignore\" with \"@ts-expect-error\"."))]
-    IgnoreInsteadOfExpectError(String, #[label] Span),
+fn ignore_instead_of_expect_error(span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(ban-ts-comment): Use \"@ts-expect-error\" instead of @ts-ignore, as \"@ts-ignore\" will do nothing if the following line is error-free.")
+        .with_help("Replace \"@ts-ignore\" with \"@ts-expect-error\".")
+        .with_labels([span1.into()])
+}
 
-    #[error("typescript-eslint(ban-ts-comment): Include a description after the @ts-{0} directive to explain why the @ts-{0} is necessary. The description must be {1} characters or longer.")]
-    #[diagnostic(severity(warning))]
-    CommentRequiresDescription(String, u64, #[label] Span),
+fn comment_requires_description(x0: &str, x1: u64, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "typescript-eslint(ban-ts-comment): Include a description after the @ts-{x0} directive to explain why the @ts-{x0} is necessary. The description must be {x1} characters or longer."
+    ))
+    .with_labels([span2.into()])
+}
 
-    #[error("typescript-eslint(ban-ts-comment): The description for the @ts-{0} directive must match the {1} format.")]
-    #[diagnostic(severity(warning))]
-    CommentDescriptionNotMatchPattern(String, String, #[label] Span),
+fn comment_description_not_match_pattern(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("typescript-eslint(ban-ts-comment): The description for the @ts-{x0} directive must match the {x1} format.")).with_labels([span2.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -168,10 +163,7 @@ impl Rule for BanTsComment {
                         if *on {
                             if directive == "ignore" {
                                 ctx.diagnostic_with_fix(
-                                    BanTsCommentDiagnostic::IgnoreInsteadOfExpectError(
-                                        directive.to_string(),
-                                        span,
-                                    ),
+                                    ignore_instead_of_expect_error(span),
                                     || {
                                         Fix::new(
                                             raw.replace("@ts-ignore", "@ts-expect-error"),
@@ -180,18 +172,15 @@ impl Rule for BanTsComment {
                                     },
                                 );
                             } else {
-                                ctx.diagnostic(BanTsCommentDiagnostic::Comment(
-                                    directive.to_string(),
-                                    span,
-                                ));
+                                ctx.diagnostic(comment(directive, span));
                             }
                         }
                     }
                     config => {
                         let description_len = description.trim().len();
                         if (description_len as u64) < self.minimum_description_length {
-                            ctx.diagnostic(BanTsCommentDiagnostic::CommentRequiresDescription(
-                                directive.to_string(),
+                            ctx.diagnostic(comment_requires_description(
+                                directive,
                                 self.minimum_description_length,
                                 span,
                             ));
@@ -199,13 +188,11 @@ impl Rule for BanTsComment {
 
                         if let DirectiveConfig::DescriptionFormat(Some(ref re)) = config {
                             if !re.is_match(description) {
-                                ctx.diagnostic(
-                                    BanTsCommentDiagnostic::CommentDescriptionNotMatchPattern(
-                                        directive.to_string(),
-                                        re.to_string(),
-                                        span,
-                                    ),
-                                );
+                                ctx.diagnostic(comment_description_not_match_pattern(
+                                    directive,
+                                    &re.to_string(),
+                                    span,
+                                ));
                             }
                         }
                     }
@@ -282,249 +269,356 @@ fn test() {
     let pass = vec![
         // ts-expect-error
         ("// just a comment containing @ts-expect-error somewhere", None),
-        (r"
+        (
+            r"
             /*
             @ts-expect-error running with long description in a block
             */
-		", None),
-        (r"
+		",
+            None,
+        ),
+        (
+            r"
             /* @ts-expect-error not on the last line
             */
-        ", None),
-        (r"
+        ",
+            None,
+        ),
+        (
+            r"
             /**
              * @ts-expect-error not on the last line
              */
-        ", None),
-        (r"
+        ",
+            None,
+        ),
+        (
+            r"
             /* not on the last line
             * @ts-expect-error
             */
-        ", None),
-        (r"
+        ",
+            None,
+        ),
+        (
+            r"
             /* @ts-expect-error
             * not on the last line */
-        ", None),
+        ",
+            None,
+        ),
         ("// @ts-expect-error", Some(serde_json::json!([{ "ts-expect-error": false }]))),
         ("// @ts-expect-error here is why the error is expected", Some(serde_json::json!([{"ts-expect-error": "allow-with-description"},]))),
-        (r"
+        (
+            r"
             /*
             * @ts-expect-error here is why the error is expected */
-        ", Some(serde_json::json!([{"ts-expect-error": "allow-with-description"},]))),
-        ("// @ts-expect-error exactly 21 characters", Some(serde_json::json!([
-          {
-            "ts-expect-error": "allow-with-description",
-            "minimumDescriptionLength": 21,
-          },
-        ]))),
-        (r"
+        ",
+            Some(serde_json::json!([{"ts-expect-error": "allow-with-description"},])),
+        ),
+        (
+            "// @ts-expect-error exactly 21 characters",
+            Some(serde_json::json!([
+              {
+                "ts-expect-error": "allow-with-description",
+                "minimumDescriptionLength": 21,
+              },
+            ])),
+        ),
+        (
+            r"
             /*
             * @ts-expect-error exactly 21 characters*/
-        ", Some(serde_json::json!([{
-            "ts-expect-error": "allow-with-description",
-            "minimumDescriptionLength": 21,
-        }]))),
-        ("// @ts-expect-error: TS1234 because xyz", Some(serde_json::json!([
-            {
-                "ts-expect-error": {
-                    "descriptionFormat": "^: TS\\d+ because .+$",
-                },
-                "minimumDescriptionLength" : 10,
-            },
-       ]))),
-       (r"
+        ",
+            Some(serde_json::json!([{
+                "ts-expect-error": "allow-with-description",
+                "minimumDescriptionLength": 21,
+            }])),
+        ),
+        (
+            "// @ts-expect-error: TS1234 because xyz",
+            Some(serde_json::json!([
+                 {
+                     "ts-expect-error": {
+                         "descriptionFormat": "^: TS\\d+ because .+$",
+                     },
+                     "minimumDescriptionLength" : 10,
+                 },
+            ])),
+        ),
+        (
+            r"
             /*
             * @ts-expect-error: TS1234 because xyz */
-        ", Some(serde_json::json!([
-            {
-                "ts-expect-error": {
-                    "descriptionFormat": "^: TS\\d+ because .+$",
-                },
-                "minimumDescriptionLength" : 10,
-            },
-       ]))),
-       ("// @ts-expect-error 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦", Some(serde_json::json!([{ "ts-expect-error": "allow-with-description" }]))),
+        ",
+            Some(serde_json::json!([
+                 {
+                     "ts-expect-error": {
+                         "descriptionFormat": "^: TS\\d+ because .+$",
+                     },
+                     "minimumDescriptionLength" : 10,
+                 },
+            ])),
+        ),
+        ("// @ts-expect-error 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦", Some(serde_json::json!([{ "ts-expect-error": "allow-with-description" }]))),
         // ts-ignore
-       ("// just a comment containing @ts-ignore somewhere", None),
-       ("// @ts-ignore", Some(serde_json::json!([{ "ts-ignore": false}]))),
-       ("// @ts-ignore I think that I am exempted from any need to follow the rules!", Some(serde_json::json!([{ "ts-ignore": "allow-with-description" }]))),
-       (r"
+        ("// just a comment containing @ts-ignore somewhere", None),
+        ("// @ts-ignore", Some(serde_json::json!([{ "ts-ignore": false}]))),
+        ("// @ts-ignore I think that I am exempted from any need to follow the rules!", Some(serde_json::json!([{ "ts-ignore": "allow-with-description" }]))),
+        (
+            r"
          /*
           @ts-ignore running with long description in a block
          */
-		", Some(serde_json::json!([
-            {
-                "ts-ignore": "allow-with-description",
-                "minimumDescriptionLength": 21,
-            },
-        ]))),
-        (r"
+		",
+            Some(serde_json::json!([
+                {
+                    "ts-ignore": "allow-with-description",
+                    "minimumDescriptionLength": 21,
+                },
+            ])),
+        ),
+        (
+            r"
             /*
              @ts-ignore
             */
-        ", None),
-        (r"
+        ",
+            None,
+        ),
+        (
+            r"
             /* @ts-ignore not on the last line
             */
-        ", None),
-        (r"
+        ",
+            None,
+        ),
+        (
+            r"
             /**
              * @ts-ignore not on the last line
              */
-        ", None),
-        (r"
+        ",
+            None,
+        ),
+        (
+            r"
             /* not on the last line
             * @ts-expect-error
             */
-        ", None),
-        (r"
+        ",
+            None,
+        ),
+        (
+            r"
             /* @ts-ignore
             * not on the last line */
-        ", None),
-        ("// @ts-ignore: TS1234 because xyz", Some(serde_json::json!([
-            {
-                "ts-ignore": {
-                    "descriptionFormat": "^: TS\\d+ because .+$",
+        ",
+            None,
+        ),
+        (
+            "// @ts-ignore: TS1234 because xyz",
+            Some(serde_json::json!([
+                {
+                    "ts-ignore": {
+                        "descriptionFormat": "^: TS\\d+ because .+$",
+                    },
+                    "minimumDescriptionLength": 10,
                 },
-                "minimumDescriptionLength": 10,
-            },
-        ]))),
-        ("// @ts-ignore 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦", Some(serde_json::json!([
-            {
-                "ts-ignore": "allow-with-description"
-            },
-        ]))),
-        (r"
+            ])),
+        ),
+        (
+            "// @ts-ignore 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦",
+            Some(serde_json::json!([
+                {
+                    "ts-ignore": "allow-with-description"
+                },
+            ])),
+        ),
+        (
+            r"
             /*
             * @ts-ignore here is why the error is expected */
-        ", Some(serde_json::json!([
-            {
-                "ts-ignore": "allow-with-description"
-            },
-        ]))),
-        ("// @ts-ignore exactly 21 characters", Some(serde_json::json!([
-            {
-                "ts-ignore": "allow-with-description",
-                "minimumDescriptionLength": 21,
-            },
-        ]))),
-        (r"
+        ",
+            Some(serde_json::json!([
+                {
+                    "ts-ignore": "allow-with-description"
+                },
+            ])),
+        ),
+        (
+            "// @ts-ignore exactly 21 characters",
+            Some(serde_json::json!([
+                {
+                    "ts-ignore": "allow-with-description",
+                    "minimumDescriptionLength": 21,
+                },
+            ])),
+        ),
+        (
+            r"
             /*
             * @ts-ignore exactly 21 characters*/
-        ", Some(serde_json::json!([
-            {
-                "ts-ignore": "allow-with-description",
-                "minimumDescriptionLength": 21,
-            },
-        ]))),
-        (r"
+        ",
+            Some(serde_json::json!([
+                {
+                    "ts-ignore": "allow-with-description",
+                    "minimumDescriptionLength": 21,
+                },
+            ])),
+        ),
+        (
+            r"
             /*
             * @ts-ignore: TS1234 because xyz */
-        ", Some(serde_json::json!([
-            {
-                "ts-ignore": {
-                    "descriptionFormat": "^: TS\\d+ because .+$",
+        ",
+            Some(serde_json::json!([
+                {
+                    "ts-ignore": {
+                        "descriptionFormat": "^: TS\\d+ because .+$",
+                    },
+                    "minimumDescriptionLength": 10,
                 },
-                "minimumDescriptionLength": 10,
-            },
-        ]))),
+            ])),
+        ),
         // ts-nocheck
         ("// just a comment containing @ts-nocheck somewhere", None),
         ("// @ts-nocheck", Some(serde_json::json!([{ "ts-nocheck": false}]))),
         ("// @ts-nocheck no doubt, people will put nonsense here from time to time just to get the rule to stop reporting, perhaps even long messages with other nonsense in them like other // @ts-nocheck or // @ts-ignore things", Some(serde_json::json!([{ "ts-nocheck": "allow-with-description" }]))),
-        (r"
+        (
+            r"
         /*
             @ts-nocheck running with long description in a block
         */",
-        Some(serde_json::json!([
-            {
-            "ts-nocheck": "allow-with-description",
-            "minimumDescriptionLength": 21,
-            },
-        ]))),
-        ("// @ts-nocheck: TS1234 because xyz", Some(serde_json::json!([
-            {
-            "ts-nocheck": {
-                "descriptionFormat": "^: TS\\d+ because .+$",
-            },
-            "minimumDescriptionLength": 10,
-            },
-        ]))),
-        ("// @ts-nocheck 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦", Some(serde_json::json!([
-            {
+            Some(serde_json::json!([
+                {
                 "ts-nocheck": "allow-with-description",
-            },
-        ]))),
+                "minimumDescriptionLength": 21,
+                },
+            ])),
+        ),
+        (
+            "// @ts-nocheck: TS1234 because xyz",
+            Some(serde_json::json!([
+                {
+                "ts-nocheck": {
+                    "descriptionFormat": "^: TS\\d+ because .+$",
+                },
+                "minimumDescriptionLength": 10,
+                },
+            ])),
+        ),
+        (
+            "// @ts-nocheck 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦",
+            Some(serde_json::json!([
+                {
+                    "ts-nocheck": "allow-with-description",
+                },
+            ])),
+        ),
         ("//// @ts-nocheck - pragma comments may contain 2 or 3 leading slashes", None),
-        (r"
+        (
+            r"
             /**
              @ts-nocheck
             */
-        ", None),
-        (r"
+        ",
+            None,
+        ),
+        (
+            r"
             /*
              @ts-nocheck
             */
-        ", None),
+        ",
+            None,
+        ),
         ("/** @ts-nocheck */", None),
         ("/* @ts-nocheck */", None),
         // ts-check
         ("// just a comment containing @ts-check somewhere", None),
-        (r"
+        (
+            r"
         /*
             @ts-check running with long description in a block
         */
-        ", None),
+        ",
+            None,
+        ),
         ("// @ts-check", Some(serde_json::json!([{ "ts-check": false}]))),
-        ("// @ts-check with a description and also with a no-op // @ts-ignore", Some(serde_json::json!([
-            {"ts-check": "allow-with-description", "minimumDescriptionLength": 3 },
-        ]))),
-        ("// @ts-check: TS1234 because xyz", Some(serde_json::json!([
-            {
-            "ts-check": {
-                "descriptionFormat": "^: TS\\d+ because .+$",
-            },
-            "minimumDescriptionLength": 10,
-            },
-        ]))),
-        ("// @ts-check 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦", Some(serde_json::json!([
-            {
-                "ts-check": "allow-with-description",
-            },
-        ]))),
-        ("//// @ts-check - pragma comments may contain 2 or 3 leading slashes", Some(serde_json::json!([
-            {
-                "ts-check": true,
-            },
-        ]))),
-        (r"
+        (
+            "// @ts-check with a description and also with a no-op // @ts-ignore",
+            Some(serde_json::json!([
+                {"ts-check": "allow-with-description", "minimumDescriptionLength": 3 },
+            ])),
+        ),
+        (
+            "// @ts-check: TS1234 because xyz",
+            Some(serde_json::json!([
+                {
+                "ts-check": {
+                    "descriptionFormat": "^: TS\\d+ because .+$",
+                },
+                "minimumDescriptionLength": 10,
+                },
+            ])),
+        ),
+        (
+            "// @ts-check 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦",
+            Some(serde_json::json!([
+                {
+                    "ts-check": "allow-with-description",
+                },
+            ])),
+        ),
+        (
+            "//// @ts-check - pragma comments may contain 2 or 3 leading slashes",
+            Some(serde_json::json!([
+                {
+                    "ts-check": true,
+                },
+            ])),
+        ),
+        (
+            r"
             /**
              @ts-check
             */
-        ", Some(serde_json::json!([
-            {
-                "ts-check": true,
-            },
-        ]))),
-        (r"
+        ",
+            Some(serde_json::json!([
+                {
+                    "ts-check": true,
+                },
+            ])),
+        ),
+        (
+            r"
             /*
              @ts-check
             */
-        ", Some(serde_json::json!([
-            {
-                "ts-check": true,
-            },
-        ]))),
-        ("/** @ts-check */", Some(serde_json::json!([
-            {
-                "ts-check": true,
-            },
-        ]))),
-        ("/* @ts-check */", Some(serde_json::json!([
-            {
-                "ts-check": true,
-            },
-        ]))),
+        ",
+            Some(serde_json::json!([
+                {
+                    "ts-check": true,
+                },
+            ])),
+        ),
+        (
+            "/** @ts-check */",
+            Some(serde_json::json!([
+                {
+                    "ts-check": true,
+                },
+            ])),
+        ),
+        (
+            "/* @ts-check */",
+            Some(serde_json::json!([
+                {
+                    "ts-check": true,
+                },
+            ])),
+        ),
     ];
 
     // A total of 57 test cases failed.
diff --git a/crates/oxc_linter/src/rules/typescript/ban_tslint_comment.rs b/crates/oxc_linter/src/rules/typescript/ban_tslint_comment.rs
index c5e7087984a8..568580c57d54 100644
--- a/crates/oxc_linter/src/rules/typescript/ban_tslint_comment.rs
+++ b/crates/oxc_linter/src/rules/typescript/ban_tslint_comment.rs
@@ -1,18 +1,18 @@
 use lazy_static::lazy_static;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use regex::Regex;
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(ban-tslint-comment): tslint comment detected: \"{0}\"")]
-#[diagnostic(severity(warning))]
-struct BanTslintCommentDiagnostic(String, #[label] pub Span);
+fn ban_tslint_comment_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "typescript-eslint(ban-tslint-comment): tslint comment detected: \"{x0}\""
+    ))
+    .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct BanTslintComment;
@@ -47,7 +47,7 @@ impl Rule for BanTslintComment {
                     get_full_comment(source_text_len, span.start, span.end, kind.is_multi_line());
 
                 ctx.diagnostic_with_fix(
-                    BanTslintCommentDiagnostic(raw.trim().to_string(), comment_span),
+                    ban_tslint_comment_diagnostic(raw.trim(), comment_span),
                     || Fix::delete(comment_span),
                 );
             }
diff --git a/crates/oxc_linter/src/rules/typescript/ban_types.rs b/crates/oxc_linter/src/rules/typescript/ban_types.rs
index 51951055e5d0..09bfb563ba5f 100644
--- a/crates/oxc_linter/src/rules/typescript/ban_types.rs
+++ b/crates/oxc_linter/src/rules/typescript/ban_types.rs
@@ -1,32 +1,34 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-pub enum BanTypesDiagnostic {
-    #[error("typescript-eslint(ban-types): Do not use {0:?} as a type. Use \"{1}\" instead")]
-    #[diagnostic(severity(warning))]
-    Type(CompactStr, String, #[label] Span),
+fn type_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "typescript-eslint(ban-types): Do not use {x0:?} as a type. Use \"{x1}\" instead"
+    ))
+    .with_labels([span2.into()])
+}
 
-    #[error("typescript-eslint(ban-types): Prefer explicitly define the object shape")]
-    #[diagnostic(severity(warning), help("This type means \"any non-nullish value\", which is slightly better than 'unknown', but it's still a broad type"))]
-    TypeLiteral(#[label] Span),
+fn type_literal(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(ban-types): Prefer explicitly define the object shape")
+        .with_help("This type means \"any non-nullish value\", which is slightly better than 'unknown', but it's still a broad type")
+        .with_labels([span0.into()])
+}
 
-    #[error("typescript-eslint(ban-types): Don't use `Function` as a type")]
-    #[diagnostic(severity(warning), help("The `Function` type accepts any function-like value"))]
-    Function(#[label] Span),
+fn function(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(ban-types): Don't use `Function` as a type")
+        .with_help("The `Function` type accepts any function-like value")
+        .with_labels([span0.into()])
+}
 
-    #[error(
-        "typescript-eslint(ban-types): 'The `Object` type actually means \"any non-nullish value\""
-    )]
-    #[diagnostic(severity(warning))]
-    Object(#[label] Span),
+fn object(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "typescript-eslint(ban-types): 'The `Object` type actually means \"any non-nullish value\"",
+    )
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -62,24 +64,24 @@ impl Rule for BanTypes {
 
                 match name.as_str() {
                     "String" | "Boolean" | "Number" | "Symbol" | "BigInt" => {
-                        ctx.diagnostic(BanTypesDiagnostic::Type(
-                            name.to_compact_str(),
-                            name.to_lowercase(),
+                        ctx.diagnostic(type_diagnostic(
+                            name.as_str(),
+                            &name.to_lowercase(),
                             typ.span,
                         ));
                     }
                     "Object" => {
-                        ctx.diagnostic(BanTypesDiagnostic::Object(typ.span));
+                        ctx.diagnostic(object(typ.span));
                     }
                     "Function" => {
-                        ctx.diagnostic(BanTypesDiagnostic::Function(typ.span));
+                        ctx.diagnostic(function(typ.span));
                     }
                     _ => {}
                 }
             }
             AstKind::TSTypeLiteral(typ) => {
                 if typ.members.is_empty() {
-                    ctx.diagnostic(BanTypesDiagnostic::TypeLiteral(typ.span));
+                    ctx.diagnostic(type_literal(typ.span));
                 }
             }
             _ => {}
diff --git a/crates/oxc_linter/src/rules/typescript/consistent_type_definitions.rs b/crates/oxc_linter/src/rules/typescript/consistent_type_definitions.rs
index 3054aa392416..e53e43d9539b 100644
--- a/crates/oxc_linter/src/rules/typescript/consistent_type_definitions.rs
+++ b/crates/oxc_linter/src/rules/typescript/consistent_type_definitions.rs
@@ -2,23 +2,21 @@ use oxc_ast::{
     ast::{ExportDefaultDeclarationKind, TSType},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(consistent-type-definitions):")]
-#[diagnostic(severity(warning), help("Use an `{0}` instead of a `{1}`"))]
-struct ConsistentTypeDefinitionsDiagnostic(
-    &'static str,
-    &'static str,
-    #[label("Use an `{0}` instead of a `{1}`")] pub Span,
-);
+fn consistent_type_definitions_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(consistent-type-definitions):")
+        .with_help(format!("Use an `{x0}` instead of a `{x1}`"))
+        .with_labels([LabeledSpan::new_with_span(
+            Some(format!("Use an `{x0}` instead of a `{x1}`")),
+            span2,
+        )])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ConsistentTypeDefinitions {
@@ -97,7 +95,7 @@ impl Rule for ConsistentTypeDefinitions {
                             &ctx.source_text()[body_span.start as usize..body_span.end as usize];
 
                         ctx.diagnostic_with_fix(
-                            ConsistentTypeDefinitionsDiagnostic(
+                            consistent_type_definitions_diagnostic(
                                 "interface",
                                 "type",
                                 Span::new(start, start + 4),
@@ -154,7 +152,7 @@ impl Rule for ConsistentTypeDefinitions {
                     };
 
                     ctx.diagnostic_with_fix(
-                        ConsistentTypeDefinitionsDiagnostic(
+                        consistent_type_definitions_diagnostic(
                             "type",
                             "interface",
                             Span::new(decl.span.start, decl.span.start + 9),
@@ -212,7 +210,7 @@ impl Rule for ConsistentTypeDefinitions {
                 };
 
                 ctx.diagnostic_with_fix(
-                    ConsistentTypeDefinitionsDiagnostic(
+                    consistent_type_definitions_diagnostic(
                         "type",
                         "interface",
                         Span::new(start, start + 9),
diff --git a/crates/oxc_linter/src/rules/typescript/no_duplicate_enum_values.rs b/crates/oxc_linter/src/rules/typescript/no_duplicate_enum_values.rs
index 30a297cb29bd..21952ce5c22e 100644
--- a/crates/oxc_linter/src/rules/typescript/no_duplicate_enum_values.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_duplicate_enum_values.rs
@@ -1,22 +1,20 @@
 use oxc_ast::ast::Expression;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{Atom, Span};
 use rustc_hash::FxHashMap;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(no-duplicate-enum-values): Disallow duplicate enum member values")]
-#[diagnostic(
-    severity(warning),
-    help("Duplicate values can lead to bugs that are hard to track down")
-)]
-struct NoDuplicateEnumValuesDiagnostic(#[label] Span, #[label] Span);
+fn no_duplicate_enum_values_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "typescript-eslint(no-duplicate-enum-values): Disallow duplicate enum member values",
+    )
+    .with_help("Duplicate values can lead to bugs that are hard to track down")
+    .with_labels([span0.into(), span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDuplicateEnumValues;
@@ -42,24 +40,28 @@ declare_oxc_lint!(
 impl Rule for NoDuplicateEnumValues {
     #[allow(clippy::float_cmp)]
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::TSEnumDeclaration(enum_body) = node.kind() else { return };
+        let AstKind::TSEnumDeclaration(enum_body) = node.kind() else {
+            return;
+        };
         let mut seen_number_values: Vec<(f64, Span)> = vec![];
         let mut seen_string_values: FxHashMap<&Atom, Span> = FxHashMap::default();
         for enum_member in &enum_body.members {
-            let Some(initializer) = &enum_member.initializer else { continue };
+            let Some(initializer) = &enum_member.initializer else {
+                continue;
+            };
             match initializer {
                 Expression::NumericLiteral(num) => {
                     if let Some((_, old_span)) =
                         seen_number_values.iter().find(|(v, _)| *v == num.value)
                     {
-                        ctx.diagnostic(NoDuplicateEnumValuesDiagnostic(*old_span, num.span));
+                        ctx.diagnostic(no_duplicate_enum_values_diagnostic(*old_span, num.span));
                     } else {
                         seen_number_values.push((num.value, num.span));
                     }
                 }
                 Expression::StringLiteral(s) => {
                     if let Some(old_span) = seen_string_values.insert(&s.value, s.span) {
-                        ctx.diagnostic(NoDuplicateEnumValuesDiagnostic(old_span, s.span));
+                        ctx.diagnostic(no_duplicate_enum_values_diagnostic(old_span, s.span));
                     }
                 }
                 _ => {}
diff --git a/crates/oxc_linter/src/rules/typescript/no_empty_interface.rs b/crates/oxc_linter/src/rules/typescript/no_empty_interface.rs
index 7f5f2d6c9432..49f39809b1b3 100644
--- a/crates/oxc_linter/src/rules/typescript/no_empty_interface.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_empty_interface.rs
@@ -1,25 +1,22 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use serde_json::Value;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(no-empty-interface): an empty interface is equivalent to `{{}}`")]
-#[diagnostic(severity(warning))]
-struct NoEmptyInterfaceDiagnostic(#[label] pub Span);
+fn no_empty_interface_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "typescript-eslint(no-empty-interface): an empty interface is equivalent to `{}`",
+    )
+    .with_labels([span0.into()])
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "typescript-eslint(no-empty-interface): an interface declaring no members is equivalent to its supertype"
-)]
-#[diagnostic(severity(warning))]
-struct NoEmptyInterfaceExtendDiagnostic(#[label] pub Span);
+fn no_empty_interface_extend_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(no-empty-interface): an interface declaring no members is equivalent to its supertype").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoEmptyInterface {
@@ -60,12 +57,12 @@ impl Rule for NoEmptyInterface {
             if interface.body.body.is_empty() {
                 match &interface.extends {
                     None => {
-                        ctx.diagnostic(NoEmptyInterfaceDiagnostic(interface.span));
+                        ctx.diagnostic(no_empty_interface_diagnostic(interface.span));
                     }
 
                     Some(extends) if extends.len() == 1 => {
                         if !self.allow_single_extends {
-                            ctx.diagnostic(NoEmptyInterfaceExtendDiagnostic(interface.span));
+                            ctx.diagnostic(no_empty_interface_extend_diagnostic(interface.span));
                         }
                     }
                     _ => {}
diff --git a/crates/oxc_linter/src/rules/typescript/no_explicit_any.rs b/crates/oxc_linter/src/rules/typescript/no_explicit_any.rs
index fa40260d2e14..728129be6c29 100644
--- a/crates/oxc_linter/src/rules/typescript/no_explicit_any.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_explicit_any.rs
@@ -1,19 +1,18 @@
 use crate::Fix;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use serde_json::Value;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(no-explicit-any): Unexpected any. Specify a different type.")]
-#[diagnostic(severity(warning), help("Use `unknown` instead, this will force you to explicitly, and safely, assert the type is correct."))]
-struct NoExplicitAnyDiagnostic(#[label] pub Span);
+fn no_explicit_any_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(no-explicit-any): Unexpected any. Specify a different type.")
+        .with_help("Use `unknown` instead, this will force you to explicitly, and safely, assert the type is correct.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoExplicitAny {
@@ -90,22 +89,26 @@ declare_oxc_lint!(
 
 impl Rule for NoExplicitAny {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::TSAnyKeyword(any) = node.kind() else { return };
+        let AstKind::TSAnyKeyword(any) = node.kind() else {
+            return;
+        };
         if self.ignore_rest_args && Self::is_in_rest(node, ctx) {
             return;
         }
 
         if self.fix_to_unknown {
-            ctx.diagnostic_with_fix(NoExplicitAnyDiagnostic(any.span), || {
+            ctx.diagnostic_with_fix(no_explicit_any_diagnostic(any.span), || {
                 Fix::new("unknown", any.span)
             });
         } else {
-            ctx.diagnostic(NoExplicitAnyDiagnostic(any.span));
+            ctx.diagnostic(no_explicit_any_diagnostic(any.span));
         }
     }
 
     fn from_configuration(value: Value) -> Self {
-        let Some(cfg) = value.get(0) else { return Self::default() };
+        let Some(cfg) = value.get(0) else {
+            return Self::default();
+        };
         let fix_to_unknown = cfg.get("fixToUnknown").and_then(Value::as_bool).unwrap_or(false);
         let ignore_rest_args = cfg.get("ignoreRestArgs").and_then(Value::as_bool).unwrap_or(false);
 
diff --git a/crates/oxc_linter/src/rules/typescript/no_extra_non_null_assertion.rs b/crates/oxc_linter/src/rules/typescript/no_extra_non_null_assertion.rs
index c442c57a434d..21cfbf1662f4 100644
--- a/crates/oxc_linter/src/rules/typescript/no_extra_non_null_assertion.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_extra_non_null_assertion.rs
@@ -1,17 +1,17 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(no-extra-non-null-assertion): extra non-null assertion")]
-#[diagnostic(severity(warning))]
-struct NoExtraNonNullAssertionDiagnostic(#[label] pub Span);
+fn no_extra_non_null_assertion_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "typescript-eslint(no-extra-non-null-assertion): extra non-null assertion",
+    )
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoExtraNonNullAssertion;
@@ -65,7 +65,7 @@ impl Rule for NoExtraNonNullAssertion {
 
         if let Some(expr) = expr {
             let end = expr.span.end - 1;
-            ctx.diagnostic(NoExtraNonNullAssertionDiagnostic(Span::new(end, end)));
+            ctx.diagnostic(no_extra_non_null_assertion_diagnostic(Span::new(end, end)));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/typescript/no_misused_new.rs b/crates/oxc_linter/src/rules/typescript/no_misused_new.rs
index 73ce6f8fe8bf..56d76d8f65c8 100644
--- a/crates/oxc_linter/src/rules/typescript/no_misused_new.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_misused_new.rs
@@ -2,27 +2,28 @@ use oxc_ast::{
     ast::{ClassElement, PropertyKey, TSSignature, TSType, TSTypeName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(no-misused-new): Interfaces cannot be constructed, only classes.")]
-#[diagnostic(severity(warning), help("Consider removing this method from your interface."))]
-struct NoMisusedNewInterfaceDiagnostic(#[label] pub Span);
+fn no_misused_new_interface_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "typescript-eslint(no-misused-new): Interfaces cannot be constructed, only classes.",
+    )
+    .with_help("Consider removing this method from your interface.")
+    .with_labels([span0.into()])
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(no-misused-new): Class cannot have method named `new`.")]
-#[diagnostic(
-    severity(warning),
-    help("This method name is confusing, consider renaming the method to `constructor`")
-)]
-struct NoMisusedNewClassDiagnostic(#[label] pub Span);
+fn no_misused_new_class_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "typescript-eslint(no-misused-new): Class cannot have method named `new`.",
+    )
+    .with_help("This method name is confusing, consider renaming the method to `constructor`")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoMisusedNew;
@@ -69,10 +70,9 @@ impl Rule for NoMisusedNew {
                             {
                                 if let TSTypeName::IdentifierReference(id) = &type_ref.type_name {
                                     if id.name == decl_name {
-                                        ctx.diagnostic(NoMisusedNewInterfaceDiagnostic(Span::new(
-                                            sig.span.start,
-                                            sig.span.start + 3,
-                                        )));
+                                        ctx.diagnostic(no_misused_new_interface_diagnostic(
+                                            Span::new(sig.span.start, sig.span.start + 3),
+                                        ));
                                     }
                                 }
                             }
@@ -83,7 +83,7 @@ impl Rule for NoMisusedNew {
             AstKind::TSMethodSignature(method_sig) => {
                 if let PropertyKey::StaticIdentifier(id) = &method_sig.key {
                     if id.name == "constructor" {
-                        ctx.diagnostic(NoMisusedNewInterfaceDiagnostic(method_sig.key.span()));
+                        ctx.diagnostic(no_misused_new_interface_diagnostic(method_sig.key.span()));
                     }
                 }
             }
@@ -102,7 +102,7 @@ impl Rule for NoMisusedNew {
                                             &type_ref.type_name
                                         {
                                             if current_id.name == cls_name {
-                                                ctx.diagnostic(NoMisusedNewClassDiagnostic(
+                                                ctx.diagnostic(no_misused_new_class_diagnostic(
                                                     method.key.span(),
                                                 ));
                                             }
diff --git a/crates/oxc_linter/src/rules/typescript/no_namespace.rs b/crates/oxc_linter/src/rules/typescript/no_namespace.rs
index 73f64a7a811c..31bfa0b22081 100644
--- a/crates/oxc_linter/src/rules/typescript/no_namespace.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_namespace.rs
@@ -2,22 +2,20 @@ use oxc_ast::{
     ast::{ModifierKind, TSModuleDeclarationKind, TSModuleDeclarationName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(no-namespace): ES2015 module syntax is preferred over namespaces.")]
-#[diagnostic(
-    severity(warning),
-    help("Replace the namespace with an ES2015 module or use `declare module`")
-)]
-struct NoNamespaceDiagnostic(#[label] pub Span);
+fn no_namespace_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "typescript-eslint(no-namespace): ES2015 module syntax is preferred over namespaces.",
+    )
+    .with_help("Replace the namespace with an ES2015 module or use `declare module`")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoNamespace {
@@ -63,8 +61,12 @@ impl Rule for NoNamespace {
 
     #[allow(clippy::cast_possible_truncation)]
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::TSModuleDeclaration(declaration) = node.kind() else { return };
-        let TSModuleDeclarationName::Identifier(ident) = &declaration.id else { return };
+        let AstKind::TSModuleDeclaration(declaration) = node.kind() else {
+            return;
+        };
+        let TSModuleDeclarationName::Identifier(ident) = &declaration.id else {
+            return;
+        };
 
         if ident.name == "global" {
             return;
@@ -96,14 +98,16 @@ impl Rule for NoNamespace {
             }),
         };
         if let Some(span) = span {
-            ctx.diagnostic(NoNamespaceDiagnostic(span));
+            ctx.diagnostic(no_namespace_diagnostic(span));
         }
     }
 }
 
 fn is_declaration(node: &AstNode, ctx: &LintContext) -> bool {
     ctx.nodes().iter_parents(node.id()).any(|node| {
-        let AstKind::TSModuleDeclaration(declaration) = node.kind() else { return false };
+        let AstKind::TSModuleDeclaration(declaration) = node.kind() else {
+            return false;
+        };
         declaration.modifiers.contains(ModifierKind::Declare)
     })
 }
diff --git a/crates/oxc_linter/src/rules/typescript/no_non_null_asserted_optional_chain.rs b/crates/oxc_linter/src/rules/typescript/no_non_null_asserted_optional_chain.rs
index ff34b8e36336..e01e929251b5 100644
--- a/crates/oxc_linter/src/rules/typescript/no_non_null_asserted_optional_chain.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_non_null_asserted_optional_chain.rs
@@ -2,26 +2,18 @@ use oxc_ast::{
     ast::{match_member_expression, ChainElement, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "typescript-eslint(no-non-null-asserted-optional-chain): non-null assertions after an optional chain expression"
-)]
-#[diagnostic(
-    severity(warning),
-    help(
-        "Optional chain expressions can return undefined by design - using a non-null assertion is unsafe and wrong. You should remove the non-null assertion."
-    )
-)]
-struct NoNonNullAssertedOptionalChainDiagnostic(#[label] pub Span, #[label] pub Span);
+fn no_non_null_asserted_optional_chain_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(no-non-null-asserted-optional-chain): non-null assertions after an optional chain expression")
+        .with_help("Optional chain expressions can return undefined by design - using a non-null assertion is unsafe and wrong. You should remove the non-null assertion.")
+        .with_labels([span0.into(), span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoNonNullAssertedOptionalChain;
@@ -90,7 +82,7 @@ impl Rule for NoNonNullAssertedOptionalChain {
             if let Some(chain_span) = chain_span {
                 let chain_span_end = chain_span.end;
                 let non_null_end = non_null_expr.span.end - 1;
-                ctx.diagnostic(NoNonNullAssertedOptionalChainDiagnostic(
+                ctx.diagnostic(no_non_null_asserted_optional_chain_diagnostic(
                     Span::new(chain_span_end, chain_span_end),
                     Span::new(non_null_end, non_null_end),
                 ));
diff --git a/crates/oxc_linter/src/rules/typescript/no_this_alias.rs b/crates/oxc_linter/src/rules/typescript/no_this_alias.rs
index e3d62deb2500..af2112325b3f 100644
--- a/crates/oxc_linter/src/rules/typescript/no_this_alias.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_this_alias.rs
@@ -2,34 +2,24 @@ use oxc_ast::{
     ast::{match_simple_assignment_target, AssignmentTarget, BindingPatternKind, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{CompactStr, GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(no-this-alias): Unexpected aliasing of 'this' to local variable.")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "Assigning a variable to this instead of properly using arrow lambdas may be a symptom of pre-ES6 practices or not managing scope well."
-    )
-)]
-struct NoThisAliasDiagnostic(#[label] pub Span);
-
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "typescript-eslint(no-this-alias): Unexpected aliasing of members of 'this' to local variables."
-)]
-#[diagnostic(
-    severity(warning),
-    help("Disabling destructuring of this is not a default, consider allowing destructuring")
-)]
-struct NoThisDestructureDiagnostic(#[label] pub Span);
+fn no_this_alias_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(no-this-alias): Unexpected aliasing of 'this' to local variable.")
+        .with_help("Assigning a variable to this instead of properly using arrow lambdas may be a symptom of pre-ES6 practices or not managing scope well.")
+        .with_labels([span0.into()])
+}
+
+fn no_this_destructure_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(no-this-alias): Unexpected aliasing of members of 'this' to local variables.")
+        .with_help("Disabling destructuring of this is not a default, consider allowing destructuring")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoThisAlias(Box<NoThisAliasConfig>);
@@ -115,12 +105,12 @@ impl Rule for NoThisAlias {
 
                 if let BindingPatternKind::BindingIdentifier(identifier) = &decl.id.kind {
                     if !self.allow_names.iter().any(|s| s.as_str() == identifier.name.as_str()) {
-                        ctx.diagnostic(NoThisAliasDiagnostic(identifier.span));
+                        ctx.diagnostic(no_this_alias_diagnostic(identifier.span));
                     }
 
                     return;
                 }
-                ctx.diagnostic(NoThisDestructureDiagnostic(decl.id.kind.span()));
+                ctx.diagnostic(no_this_destructure_diagnostic(decl.id.kind.span()));
             }
             AstKind::AssignmentExpression(assignment) => {
                 if !rhs_is_this_reference(&assignment.right) {
@@ -132,11 +122,11 @@ impl Rule for NoThisAlias {
                         if self.allow_destructuring {
                             return;
                         }
-                        ctx.diagnostic(NoThisDestructureDiagnostic(left.span()));
+                        ctx.diagnostic(no_this_destructure_diagnostic(left.span()));
                     }
                     AssignmentTarget::AssignmentTargetIdentifier(id) => {
                         if !self.allow_names.iter().any(|s| s.as_str() == id.name.as_str()) {
-                            ctx.diagnostic(NoThisAliasDiagnostic(id.span));
+                            ctx.diagnostic(no_this_alias_diagnostic(id.span));
                         }
                     }
                     left @ match_simple_assignment_target!(AssignmentTarget) => {
@@ -145,7 +135,7 @@ impl Rule for NoThisAlias {
                             if let Some(id) = expr.get_identifier_reference() {
                                 if !self.allow_names.iter().any(|s| s.as_str() == id.name.as_str())
                                 {
-                                    ctx.diagnostic(NoThisAliasDiagnostic(id.span));
+                                    ctx.diagnostic(no_this_alias_diagnostic(id.span));
                                 }
                             }
                         }
diff --git a/crates/oxc_linter/src/rules/typescript/no_unnecessary_type_constraint.rs b/crates/oxc_linter/src/rules/typescript/no_unnecessary_type_constraint.rs
index 248274af48f9..eb1e0951e11b 100644
--- a/crates/oxc_linter/src/rules/typescript/no_unnecessary_type_constraint.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_unnecessary_type_constraint.rs
@@ -1,24 +1,21 @@
 use oxc_ast::{ast::TSType, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "typescript-eslint(no-unnecessary-type-constraint): constraining the generic type {0:?} to {1:?} does nothing and is unnecessary"
-)]
-#[diagnostic(severity(warning), help("Remove the unnecessary {1:?} constraint"))]
-struct NoUnnecessaryTypeConstraintDiagnostic(
-    CompactStr,
-    &'static str,
-    #[label] pub Span,
-    #[label] pub Span,
-);
+fn no_unnecessary_type_constraint_diagnostic(
+    x0: &str,
+    x1: &str,
+    span2: Span,
+    span3: Span,
+) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("typescript-eslint(no-unnecessary-type-constraint): constraining the generic type {x0:?} to {x1:?} does nothing and is unnecessary"))
+        .with_help(format!("Remove the unnecessary {x1:?} constraint"))
+        .with_labels([span2.into(), span3.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnnecessaryTypeConstraint;
@@ -59,8 +56,8 @@ impl Rule for NoUnnecessaryTypeConstraint {
                         TSType::TSUnknownKeyword(t) => ("unknown", t.span),
                         _ => continue,
                     };
-                    ctx.diagnostic(NoUnnecessaryTypeConstraintDiagnostic(
-                        param.name.name.to_compact_str(),
+                    ctx.diagnostic(no_unnecessary_type_constraint_diagnostic(
+                        param.name.name.as_str(),
                         value,
                         param.name.span,
                         ty_span,
diff --git a/crates/oxc_linter/src/rules/typescript/no_unsafe_declaration_merging.rs b/crates/oxc_linter/src/rules/typescript/no_unsafe_declaration_merging.rs
index 610a2451b8f4..0aea433802e7 100644
--- a/crates/oxc_linter/src/rules/typescript/no_unsafe_declaration_merging.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_unsafe_declaration_merging.rs
@@ -1,18 +1,17 @@
 use oxc_ast::{ast::BindingIdentifier, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::SymbolId;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(no-unsafe-declaration-merging): Unsafe declaration merging between classes and interfaces.")]
-#[diagnostic(severity(warning), help("The TypeScript compiler doesn't check whether properties are initialized, which can cause lead to TypeScript not detecting code that will cause runtime errors."))]
-struct NoUnsafeDeclarationMergingDiagnostic(#[label] Span, #[label] Span);
+fn no_unsafe_declaration_merging_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(no-unsafe-declaration-merging): Unsafe declaration merging between classes and interfaces.")
+        .with_help("The TypeScript compiler doesn't check whether properties are initialized, which can cause lead to TypeScript not detecting code that will cause runtime errors.")
+        .with_labels([span0.into(), span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnsafeDeclarationMerging;
@@ -74,7 +73,7 @@ fn check_and_diagnostic(
     ctx: &LintContext<'_>,
 ) {
     if scope_ident.name.as_str() == ident.name.as_str() {
-        ctx.diagnostic(NoUnsafeDeclarationMergingDiagnostic(ident.span, scope_ident.span));
+        ctx.diagnostic(no_unsafe_declaration_merging_diagnostic(ident.span, scope_ident.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/typescript/no_var_requires.rs b/crates/oxc_linter/src/rules/typescript/no_var_requires.rs
index 08fe1562003c..2c5d99e41dc7 100644
--- a/crates/oxc_linter/src/rules/typescript/no_var_requires.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_var_requires.rs
@@ -1,17 +1,18 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{ast_util::is_global_require_call, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(no-var-requires): Require statement not part of import statement.")]
-#[diagnostic(severity(warning), help("Use ES6 style imports or import instead."))]
-struct NoVarRequiresDiagnostic(#[label] pub Span);
+fn no_var_requires_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "typescript-eslint(no-var-requires): Require statement not part of import statement.",
+    )
+    .with_help("Use ES6 style imports or import instead.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoVarRequires;
@@ -39,7 +40,9 @@ impl Rule for NoVarRequires {
         if !ctx.source_type().is_typescript() {
             return;
         }
-        let AstKind::CallExpression(expr) = node.kind() else { return };
+        let AstKind::CallExpression(expr) = node.kind() else {
+            return;
+        };
 
         if is_global_require_call(expr, ctx) {
             // If the parent is an expression statement => this is a top level require()
@@ -64,7 +67,7 @@ impl Rule for NoVarRequires {
             // If this is an expression statement, it means the `require()`'s return value is unused.
             // If the return value is unused, this isn't a problem.
             if !is_expression_statement {
-                ctx.diagnostic(NoVarRequiresDiagnostic(node.kind().span()));
+                ctx.diagnostic(no_var_requires_diagnostic(node.kind().span()));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/typescript/prefer_as_const.rs b/crates/oxc_linter/src/rules/typescript/prefer_as_const.rs
index 3062eab3ccf9..94ae8e9d89d8 100644
--- a/crates/oxc_linter/src/rules/typescript/prefer_as_const.rs
+++ b/crates/oxc_linter/src/rules/typescript/prefer_as_const.rs
@@ -1,19 +1,17 @@
 use oxc_ast::ast::{Expression, TSLiteral, TSType};
 use oxc_ast::AstKind;
+use oxc_diagnostics::OxcDiagnostic;
 
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(prefer-as-const): Expected a `const` assertion instead of a literal type annotation.")]
-#[diagnostic(severity(warning), help("You should use `as const` instead of type annotation."))]
-struct PreferAsConstDiagnostic(#[label] pub Span);
+fn prefer_as_const_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(prefer-as-const): Expected a `const` assertion instead of a literal type annotation.")
+        .with_help("You should use `as const` instead of type annotation.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferAsConst;
@@ -119,13 +117,13 @@ fn check_and_report(
         };
         if let Some(span) = error_span {
             if can_fix {
-                ctx.diagnostic_with_fix(PreferAsConstDiagnostic(span), || {
+                ctx.diagnostic_with_fix(prefer_as_const_diagnostic(span), || {
                     let start = span.start;
                     let end = span.end;
                     Fix::new("const", Span::new(start, end))
                 });
             } else {
-                ctx.diagnostic(PreferAsConstDiagnostic(span));
+                ctx.diagnostic(prefer_as_const_diagnostic(span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/typescript/prefer_enum_initializers.rs b/crates/oxc_linter/src/rules/typescript/prefer_enum_initializers.rs
index f44e70635a51..4d6a7ae4b58f 100644
--- a/crates/oxc_linter/src/rules/typescript/prefer_enum_initializers.rs
+++ b/crates/oxc_linter/src/rules/typescript/prefer_enum_initializers.rs
@@ -1,17 +1,16 @@
 use oxc_ast::{ast::TSEnumMemberName, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(prefer-enum-initializers):The value of the member {0:?} should be explicitly defined.")]
-#[diagnostic(severity(warning), help("Can be fixed to {0:?} = {1:?}."))]
-struct PreferEnumInitializersDiagnostic(CompactStr, usize, #[label] pub Span);
+fn prefer_enum_initializers_diagnostic(x0: &str, x1: usize, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("typescript-eslint(prefer-enum-initializers):The value of the member {x0:?} should be explicitly defined."))
+        .with_help(format!("Can be fixed to {x0:?} = {x1:?}."))
+        .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferEnumInitializers;
@@ -37,13 +36,15 @@ declare_oxc_lint!(
 
 impl Rule for PreferEnumInitializers {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::TSEnumDeclaration(decl) = node.kind() else { return };
+        let AstKind::TSEnumDeclaration(decl) = node.kind() else {
+            return;
+        };
 
         for (index, member) in decl.members.iter().enumerate() {
             if member.initializer.is_none() {
                 if let TSEnumMemberName::StaticIdentifier(i) = &member.id {
-                    ctx.diagnostic(PreferEnumInitializersDiagnostic(
-                        i.name.to_compact_str(),
+                    ctx.diagnostic(prefer_enum_initializers_diagnostic(
+                        i.name.as_str(),
                         index + 1,
                         member.span,
                     ));
diff --git a/crates/oxc_linter/src/rules/typescript/prefer_for_of.rs b/crates/oxc_linter/src/rules/typescript/prefer_for_of.rs
index f2f30487129f..4d5cda3dbbde 100644
--- a/crates/oxc_linter/src/rules/typescript/prefer_for_of.rs
+++ b/crates/oxc_linter/src/rules/typescript/prefer_for_of.rs
@@ -3,20 +3,19 @@ use oxc_ast::ast::{
     VariableDeclarationKind,
 };
 use oxc_ast::{ast::match_member_expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{Atom, GetSpan, Span};
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, UnaryOperator, UpdateOperator};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(prefer-for-of): Expected a `for-of` loop instead of a `for` loop with this simple iteration.")]
-#[diagnostic(severity(warning), help("Consider using a for-of loop for this simple iteration."))]
-struct PreferForOfDiagnostic(#[label] pub Span);
+fn prefer_for_of_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(prefer-for-of): Expected a `for-of` loop instead of a `for` loop with this simple iteration.")
+        .with_help("Consider using a for-of loop for this simple iteration.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferForOf;
@@ -110,7 +109,9 @@ impl<'a> ExpressionExt for Expression<'a> {
 
 impl Rule for PreferForOf {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::ForStatement(for_stmt) = node.kind() else { return };
+        let AstKind::ForStatement(for_stmt) = node.kind() else {
+            return;
+        };
 
         let Some(ForStatementInit::VariableDeclaration(for_stmt_init)) = &for_stmt.init else {
             return;
@@ -134,7 +135,9 @@ impl Rule for PreferForOf {
             return;
         }
 
-        let Some(Expression::BinaryExpression(test_expr)) = &for_stmt.test else { return };
+        let Some(Expression::BinaryExpression(test_expr)) = &for_stmt.test else {
+            return;
+        };
 
         if !matches!((&test_expr.left, test_expr.operator),
             (Expression::Identifier(id), BinaryOperator::LessThan) if id.name == var_name
@@ -143,7 +146,9 @@ impl Rule for PreferForOf {
         }
 
         let array_name = {
-            let Some(mem_expr) = test_expr.right.as_member_expression() else { return };
+            let Some(mem_expr) = test_expr.right.as_member_expression() else {
+                return;
+            };
             if !matches!(mem_expr.static_property_name(), Some(prop_name) if prop_name == "length")
             {
                 return;
@@ -161,7 +166,9 @@ impl Rule for PreferForOf {
             }
         };
 
-        let Some(update_expr) = &for_stmt.update else { return };
+        let Some(update_expr) = &for_stmt.update else {
+            return;
+        };
         if !update_expr.is_increment_of(var_name) {
             return;
         }
@@ -169,7 +176,9 @@ impl Rule for PreferForOf {
         let nodes = ctx.nodes();
         let body_span = for_stmt.body.span();
 
-        let Some(var_symbol_id) = var_symbol_id else { return };
+        let Some(var_symbol_id) = var_symbol_id else {
+            return;
+        };
         if ctx.semantic().symbol_references(var_symbol_id).any(|reference| {
             let ref_id = reference.node_id();
 
@@ -178,7 +187,9 @@ impl Rule for PreferForOf {
                 return false;
             }
 
-            let Some(ref_parent) = nodes.parent_node(ref_id) else { return true };
+            let Some(ref_parent) = nodes.parent_node(ref_id) else {
+                return true;
+            };
 
             if let Some(ref_grand_parent) = nodes.parent_node(ref_parent.id()) {
                 match ref_grand_parent.kind() {
@@ -195,7 +206,9 @@ impl Rule for PreferForOf {
             }
 
             let parent_kind = ref_parent.kind();
-            let AstKind::MemberExpression(mem_expr) = parent_kind else { return true };
+            let AstKind::MemberExpression(mem_expr) = parent_kind else {
+                return true;
+            };
             match mem_expr.object() {
                 Expression::Identifier(id) => id.name.as_str() != array_name,
                 expr if expr.is_member_expression() => {
@@ -211,7 +224,7 @@ impl Rule for PreferForOf {
         }
 
         let span = for_stmt_init.span.merge(&test_expr.span).merge(&update_expr.span());
-        ctx.diagnostic(PreferForOfDiagnostic(span));
+        ctx.diagnostic(prefer_for_of_diagnostic(span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/typescript/prefer_function_type.rs b/crates/oxc_linter/src/rules/typescript/prefer_function_type.rs
index 1cc011583924..69c201f456ad 100644
--- a/crates/oxc_linter/src/rules/typescript/prefer_function_type.rs
+++ b/crates/oxc_linter/src/rules/typescript/prefer_function_type.rs
@@ -2,22 +2,18 @@ use oxc_ast::{
     ast::{ExportDefaultDeclarationKind, Expression, TSInterfaceDeclaration, TSSignature, TSType},
     AstKind, CommentKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(prefer-function-type): Enforce using function types instead of interfaces with call signatures.")]
-#[diagnostic(
-    severity(warning),
-    help("The function type form `{0}` is generally preferred when possible for being more succinct.")
-)]
-struct PreferFunctionTypeDiagnostic(String, #[label] pub Span);
+fn prefer_function_type_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(prefer-function-type): Enforce using function types instead of interfaces with call signatures.")
+        .with_help(format!("The function type form `{x0}` is generally preferred when possible for being more succinct."))
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferFunctionType;
@@ -134,7 +130,7 @@ fn check_member(member: &TSSignature, node: &AstNode<'_>, ctx: &LintContext<'_>)
                                 ..type_parameters.span.end as usize];
 
                             ctx.diagnostic_with_fix(
-                                PreferFunctionTypeDiagnostic(suggestion.clone(), decl.span),
+                                prefer_function_type_diagnostic(&suggestion, decl.span),
                                 || {
                                     Fix::new(
                                         format!("type {type_name} = {suggestion};"),
@@ -144,7 +140,7 @@ fn check_member(member: &TSSignature, node: &AstNode<'_>, ctx: &LintContext<'_>)
                             );
                         } else {
                             ctx.diagnostic_with_fix(
-                                PreferFunctionTypeDiagnostic(suggestion.clone(), decl.span),
+                                prefer_function_type_diagnostic(&suggestion, decl.span),
                                 || {
                                     let mut is_parent_exported = false;
                                     let mut node_start = interface_decl.span.start;
@@ -224,42 +220,39 @@ fn check_member(member: &TSSignature, node: &AstNode<'_>, ctx: &LintContext<'_>)
                         }
                     }
 
-                    AstKind::TSTypeAnnotation(ts_type_annotation) => {
-                        match &ts_type_annotation.type_annotation {
-                            TSType::TSUnionType(union_type) => {
-                                union_type.types.iter().for_each(|ts_type| {
-                                    if let TSType::TSTypeLiteral(literal) = ts_type {
-                                        ctx.diagnostic_with_fix(
-                                            PreferFunctionTypeDiagnostic(
-                                                suggestion.clone(),
-                                                decl.span,
-                                            ),
-                                            || {
-                                                Fix::new(
-                                                    format!("({suggestion})"),
-                                                    Span::new(literal.span.start, literal.span.end),
-                                                )
-                                            },
-                                        );
-                                    }
-                                });
-                            }
-
-                            TSType::TSTypeLiteral(literal) => ctx.diagnostic_with_fix(
-                                PreferFunctionTypeDiagnostic(suggestion.clone(), decl.span),
-                                || {
-                                    Fix::new(
-                                        suggestion.to_string(),
-                                        Span::new(literal.span.start, literal.span.end),
-                                    )
-                                },
-                            ),
+                    AstKind::TSTypeAnnotation(ts_type_annotation) => match &ts_type_annotation
+                        .type_annotation
+                    {
+                        TSType::TSUnionType(union_type) => {
+                            union_type.types.iter().for_each(|ts_type| {
+                                if let TSType::TSTypeLiteral(literal) = ts_type {
+                                    ctx.diagnostic_with_fix(
+                                        prefer_function_type_diagnostic(&suggestion, decl.span),
+                                        || {
+                                            Fix::new(
+                                                format!("({suggestion})"),
+                                                Span::new(literal.span.start, literal.span.end),
+                                            )
+                                        },
+                                    );
+                                }
+                            });
+                        }
 
-                            _ => {
-                                ctx.diagnostic(PreferFunctionTypeDiagnostic(suggestion, decl.span));
-                            }
+                        TSType::TSTypeLiteral(literal) => ctx.diagnostic_with_fix(
+                            prefer_function_type_diagnostic(&suggestion, decl.span),
+                            || {
+                                Fix::new(
+                                    suggestion.to_string(),
+                                    Span::new(literal.span.start, literal.span.end),
+                                )
+                            },
+                        ),
+
+                        _ => {
+                            ctx.diagnostic(prefer_function_type_diagnostic(&suggestion, decl.span));
                         }
-                    }
+                    },
 
                     AstKind::TSTypeAliasDeclaration(ts_type_alias_decl) => {
                         match &ts_type_alias_decl.type_annotation {
@@ -269,8 +262,8 @@ fn check_member(member: &TSSignature, node: &AstNode<'_>, ctx: &LintContext<'_>)
                                         let body = &literal.members;
                                         if body.len() == 1 {
                                             ctx.diagnostic_with_fix(
-                                                PreferFunctionTypeDiagnostic(
-                                                    suggestion.clone(),
+                                                prefer_function_type_diagnostic(
+                                                    &suggestion,
                                                     decl.span,
                                                 ),
                                                 || {
@@ -294,8 +287,8 @@ fn check_member(member: &TSSignature, node: &AstNode<'_>, ctx: &LintContext<'_>)
                                         let body = &literal.members;
                                         if body.len() == 1 {
                                             ctx.diagnostic_with_fix(
-                                                PreferFunctionTypeDiagnostic(
-                                                    suggestion.clone(),
+                                                prefer_function_type_diagnostic(
+                                                    &suggestion,
                                                     decl.span,
                                                 ),
                                                 || {
@@ -314,7 +307,7 @@ fn check_member(member: &TSSignature, node: &AstNode<'_>, ctx: &LintContext<'_>)
                             }
 
                             TSType::TSTypeLiteral(literal) => ctx.diagnostic_with_fix(
-                                PreferFunctionTypeDiagnostic(suggestion.clone(), decl.span),
+                                prefer_function_type_diagnostic(&suggestion, decl.span),
                                 || {
                                     Fix::new(
                                         suggestion.to_string(),
@@ -327,7 +320,7 @@ fn check_member(member: &TSSignature, node: &AstNode<'_>, ctx: &LintContext<'_>)
                         }
                     }
 
-                    _ => ctx.diagnostic(PreferFunctionTypeDiagnostic(suggestion, decl.span)),
+                    _ => ctx.diagnostic(prefer_function_type_diagnostic(&suggestion, decl.span)),
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/typescript/prefer_literal_enum_member.rs b/crates/oxc_linter/src/rules/typescript/prefer_literal_enum_member.rs
index b534f66420eb..88a861b1ed22 100644
--- a/crates/oxc_linter/src/rules/typescript/prefer_literal_enum_member.rs
+++ b/crates/oxc_linter/src/rules/typescript/prefer_literal_enum_member.rs
@@ -1,18 +1,17 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::{BinaryOperator, UnaryOperator};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(prefer-literal-enum-member): Explicit enum value must only be a literal value (string, number, boolean, etc).")]
-#[diagnostic(severity(warning), help("Require all enum members to be literal values."))]
-struct PreferLiteralEnumMemberDiagnostic(#[label] pub Span);
+fn prefer_literal_enum_member_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(prefer-literal-enum-member): Explicit enum value must only be a literal value (string, number, boolean, etc).")
+        .with_help("Require all enum members to be literal values.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferLiteralEnumMember {
@@ -54,8 +53,12 @@ impl Rule for PreferLiteralEnumMember {
         }
     }
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::TSEnumMember(decl) = node.kind() else { return };
-        let Some(initializer) = &decl.initializer else { return };
+        let AstKind::TSEnumMember(decl) = node.kind() else {
+            return;
+        };
+        let Some(initializer) = &decl.initializer else {
+            return;
+        };
         if initializer.is_literal() {
             return;
         }
@@ -101,7 +104,7 @@ impl Rule for PreferLiteralEnumMember {
             }
         }
 
-        ctx.diagnostic(PreferLiteralEnumMemberDiagnostic(decl.span));
+        ctx.diagnostic(prefer_literal_enum_member_diagnostic(decl.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/typescript/prefer_ts_expect_error.rs b/crates/oxc_linter/src/rules/typescript/prefer_ts_expect_error.rs
index 9e0e16061e53..204472041ec6 100644
--- a/crates/oxc_linter/src/rules/typescript/prefer_ts_expect_error.rs
+++ b/crates/oxc_linter/src/rules/typescript/prefer_ts_expect_error.rs
@@ -1,23 +1,17 @@
 use oxc_ast::CommentKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::fixer::Fix;
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "typescript-eslint(prefer-ts-expect-error): Enforce using `@ts-expect-error` over `@ts-ignore`"
-)]
-#[diagnostic(
-    severity(warning),
-    help("Use \"@ts-expect-error\" to ensure an error is actually being suppressed.")
-)]
-struct PreferTsExpectErrorDiagnostic(#[label] pub Span);
+fn prefer_ts_expect_error_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("typescript-eslint(prefer-ts-expect-error): Enforce using `@ts-expect-error` over `@ts-ignore`")
+        .with_help("Use \"@ts-expect-error\" to ensure an error is actually being suppressed.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferTsExpectError;
@@ -62,7 +56,7 @@ impl Rule for PreferTsExpectError {
 
             if kind.is_single_line() {
                 let comment_span = Span::new(span.start - 2, span.end);
-                ctx.diagnostic_with_fix(PreferTsExpectErrorDiagnostic(comment_span), || {
+                ctx.diagnostic_with_fix(prefer_ts_expect_error_diagnostic(comment_span), || {
                     Fix::new(
                         format!("//{}", raw.replace("@ts-ignore", "@ts-expect-error")),
                         comment_span,
@@ -70,7 +64,7 @@ impl Rule for PreferTsExpectError {
                 });
             } else {
                 let comment_span = Span::new(span.start - 2, span.end + 2);
-                ctx.diagnostic_with_fix(PreferTsExpectErrorDiagnostic(comment_span), || {
+                ctx.diagnostic_with_fix(prefer_ts_expect_error_diagnostic(comment_span), || {
                     Fix::new(
                         format!("/*{}*/", raw.replace("@ts-ignore", "@ts-expect-error")),
                         comment_span,
diff --git a/crates/oxc_linter/src/rules/typescript/triple_slash_reference.rs b/crates/oxc_linter/src/rules/typescript/triple_slash_reference.rs
index c23e905f01a8..cbe30e7b82a2 100644
--- a/crates/oxc_linter/src/rules/typescript/triple_slash_reference.rs
+++ b/crates/oxc_linter/src/rules/typescript/triple_slash_reference.rs
@@ -1,22 +1,21 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use std::collections::HashMap;
 
 use oxc_ast::{
     ast::{Statement, TSModuleReference},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("typescript-eslint(triple-slash-reference): Do not use a triple slash reference for {0}, use `import` style instead.")]
-#[diagnostic(severity(warning), help("Use of triple-slash reference type directives is generally discouraged in favor of ECMAScript Module imports."))]
-struct TripleSlashReferenceDiagnostic(String, #[label] pub Span);
+fn triple_slash_reference_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("typescript-eslint(triple-slash-reference): Do not use a triple slash reference for {x0}, use `import` style instead."))
+        .with_help("Use of triple-slash reference type directives is generally discouraged in favor of ECMAScript Module imports.")
+        .with_labels([span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct TripleSlashReference(Box<TripleSlashReferenceConfig>);
@@ -103,7 +102,9 @@ impl Rule for TripleSlashReference {
         }))
     }
     fn run_once(&self, ctx: &LintContext) {
-        let Some(root) = ctx.nodes().root_node() else { return };
+        let Some(root) = ctx.nodes().root_node() else {
+            return;
+        };
         let AstKind::Program(program) = root.kind() else { unreachable!() };
 
         // We don't need to iterate over all comments since Triple-slash directives are only valid at the top of their containing file.
@@ -118,8 +119,8 @@ impl Rule for TripleSlashReference {
                     || (group1 == "path" && self.path == PathOption::Never)
                     || (group1 == "lib" && self.lib == LibOption::Never)
                 {
-                    ctx.diagnostic(TripleSlashReferenceDiagnostic(
-                        group2.to_string(),
+                    ctx.diagnostic(triple_slash_reference_diagnostic(
+                        &group2,
                         Span::new(*start - 2, comment.end),
                     ));
                 }
@@ -137,8 +138,8 @@ impl Rule for TripleSlashReference {
                         TSModuleReference::ExternalModuleReference(ref mod_ref) => {
                             if let Some(v) = refs_for_import.get(mod_ref.expression.value.as_str())
                             {
-                                ctx.diagnostic(TripleSlashReferenceDiagnostic(
-                                    mod_ref.expression.value.to_string(),
+                                ctx.diagnostic(triple_slash_reference_diagnostic(
+                                    &mod_ref.expression.value,
                                     *v,
                                 ));
                             }
@@ -148,8 +149,8 @@ impl Rule for TripleSlashReference {
                     },
                     Statement::ImportDeclaration(decl) => {
                         if let Some(v) = refs_for_import.get(decl.source.value.as_str()) {
-                            ctx.diagnostic(TripleSlashReferenceDiagnostic(
-                                decl.source.value.to_string(),
+                            ctx.diagnostic(triple_slash_reference_diagnostic(
+                                &decl.source.value,
                                 *v,
                             ));
                         }
diff --git a/crates/oxc_linter/src/rules/unicorn/catch_error_name.rs b/crates/oxc_linter/src/rules/unicorn/catch_error_name.rs
index ff1e35178b51..7c280552575d 100644
--- a/crates/oxc_linter/src/rules/unicorn/catch_error_name.rs
+++ b/crates/oxc_linter/src/rules/unicorn/catch_error_name.rs
@@ -2,20 +2,17 @@ use oxc_ast::{
     ast::{Argument, BindingPatternKind, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::SymbolId;
 use oxc_span::{Atom, CompactStr, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(catch-error-name): The catch parameter {0:?} should be named {1:?}")]
-#[diagnostic(severity(warning))]
-struct CatchErrorNameDiagnostic(CompactStr, CompactStr, #[label] pub Span);
+fn catch_error_name_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(catch-error-name): The catch parameter {x0:?} should be named {x1:?}")).with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct CatchErrorName(Box<CatchErrorNameConfig>);
@@ -94,18 +91,18 @@ impl Rule for CatchErrorName {
 
                 if binding_ident.name.starts_with('_') {
                     if symbol_has_references(binding_ident.symbol_id.get(), ctx) {
-                        ctx.diagnostic(CatchErrorNameDiagnostic(
-                            binding_ident.name.to_compact_str(),
-                            self.name.clone(),
+                        ctx.diagnostic(catch_error_name_diagnostic(
+                            binding_ident.name.as_str(),
+                            &self.name,
                             binding_ident.span,
                         ));
                     }
                     return;
                 }
 
-                ctx.diagnostic(CatchErrorNameDiagnostic(
-                    binding_ident.name.to_compact_str(),
-                    self.name.clone(),
+                ctx.diagnostic(catch_error_name_diagnostic(
+                    binding_ident.name.as_str(),
+                    &self.name,
                     binding_ident.span,
                 ));
             }
@@ -141,7 +138,7 @@ impl CatchErrorName {
         &self,
         arg0: &Argument,
         ctx: &LintContext,
-    ) -> Option<CatchErrorNameDiagnostic> {
+    ) -> Option<OxcDiagnostic> {
         let expr = arg0.as_expression()?;
         let expr = expr.without_parenthesized();
 
@@ -154,9 +151,9 @@ impl CatchErrorName {
 
                     if v.name.starts_with('_') {
                         if symbol_has_references(v.symbol_id.get(), ctx) {
-                            ctx.diagnostic(CatchErrorNameDiagnostic(
-                                v.name.to_compact_str(),
-                                self.name.clone(),
+                            ctx.diagnostic(catch_error_name_diagnostic(
+                                v.name.as_str(),
+                                &self.name,
                                 v.span,
                             ));
                         }
@@ -164,11 +161,7 @@ impl CatchErrorName {
                         return None;
                     }
 
-                    return Some(CatchErrorNameDiagnostic(
-                        v.name.to_compact_str(),
-                        self.name.clone(),
-                        v.span,
-                    ));
+                    return Some(catch_error_name_diagnostic(v.name.as_str(), &self.name, v.span));
                 }
             }
         }
@@ -182,9 +175,9 @@ impl CatchErrorName {
 
                     if binding_ident.name.starts_with('_') {
                         if symbol_has_references(binding_ident.symbol_id.get(), ctx) {
-                            ctx.diagnostic(CatchErrorNameDiagnostic(
-                                binding_ident.name.to_compact_str(),
-                                self.name.clone(),
+                            ctx.diagnostic(catch_error_name_diagnostic(
+                                binding_ident.name.as_str(),
+                                &self.name,
                                 binding_ident.span,
                             ));
                         }
@@ -192,9 +185,9 @@ impl CatchErrorName {
                         return None;
                     }
 
-                    return Some(CatchErrorNameDiagnostic(
-                        binding_ident.name.to_compact_str(),
-                        self.name.clone(),
+                    return Some(catch_error_name_diagnostic(
+                        binding_ident.name.as_str(),
+                        &self.name,
                         binding_ident.span,
                     ));
                 }
diff --git a/crates/oxc_linter/src/rules/unicorn/empty_brace_spaces.rs b/crates/oxc_linter/src/rules/unicorn/empty_brace_spaces.rs
index 124a163171df..efbca9174fda 100644
--- a/crates/oxc_linter/src/rules/unicorn/empty_brace_spaces.rs
+++ b/crates/oxc_linter/src/rules/unicorn/empty_brace_spaces.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(empty-brace-spaces): No spaces inside empty pair of braces allowed")]
-#[diagnostic(severity(warning), help("There should be no spaces or new lines inside a pair of empty braces as it affects the overall readability of the code."))]
-struct EmptyBraceSpacesDiagnostic(#[label] pub Span);
+fn empty_brace_spaces_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(empty-brace-spaces): No spaces inside empty pair of braces allowed")
+        .with_help("There should be no spaces or new lines inside a pair of empty braces as it affects the overall readability of the code.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct EmptyBraceSpaces;
@@ -46,9 +45,10 @@ impl Rule for EmptyBraceSpaces {
                     && end - start > static_leading_count + 2
                     && !ctx.semantic().trivias().has_comments_between(static_block.span)
                 {
-                    ctx.diagnostic_with_fix(EmptyBraceSpacesDiagnostic(static_block.span), || {
-                        Fix::new("static {}", static_block.span)
-                    });
+                    ctx.diagnostic_with_fix(
+                        empty_brace_spaces_diagnostic(static_block.span),
+                        || Fix::new("static {}", static_block.span),
+                    );
                 }
             }
             AstKind::ObjectExpression(obj) => {
@@ -88,7 +88,7 @@ fn remove_empty_braces_spaces(ctx: &LintContext, is_empty_body: bool, span: Span
 
     if is_empty_body && end - start > 2 && !ctx.semantic().trivias().has_comments_between(span) {
         // length of "{}"
-        ctx.diagnostic_with_fix(EmptyBraceSpacesDiagnostic(span), || Fix::new("{}", span));
+        ctx.diagnostic_with_fix(empty_brace_spaces_diagnostic(span), || Fix::new("{}", span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/error_message.rs b/crates/oxc_linter/src/rules/unicorn/error_message.rs
index 77216bc770c4..bdb6e10d621f 100644
--- a/crates/oxc_linter/src/rules/unicorn/error_message.rs
+++ b/crates/oxc_linter/src/rules/unicorn/error_message.rs
@@ -2,24 +2,31 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression, NewExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[diagnostic(severity(warning))]
-pub enum ErrorMessageDiagnostic {
-    #[error("eslint-plugin-unicorn(error-message): Pass a message to the {0:1} constructor.")]
-    MissingMessage(CompactStr, #[label] Span),
-    #[error("eslint-plugin-unicorn(error-message): Error message should not be an empty string.")]
-    EmptyMessage(#[label] Span),
-    #[error("eslint-plugin-unicorn(error-message): Error message should be a string.")]
-    NotString(#[label] Span),
+fn missing_message(x0: &str, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(error-message): Pass a message to the {x0:1} constructor."
+    ))
+    .with_labels([span1.into()])
+}
+
+fn empty_message(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(error-message): Error message should not be an empty string.",
+    )
+    .with_labels([span0.into()])
+}
+
+fn not_string(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(error-message): Error message should be a string.",
+    )
+    .with_labels([span0.into()])
 }
 
 #[derive(Default, Debug, Clone)]
@@ -83,28 +90,25 @@ impl Rule for ErrorMessage {
         let message_argument = args.get(message_argument_idx);
 
         let Some(arg) = message_argument else {
-            return ctx.diagnostic(ErrorMessageDiagnostic::MissingMessage(
-                constructor_name.to_compact_str(),
-                span,
-            ));
+            return ctx.diagnostic(missing_message(constructor_name.as_str(), span));
         };
 
         match arg {
             Argument::StringLiteral(lit) => {
                 if lit.value.is_empty() {
-                    ctx.diagnostic(ErrorMessageDiagnostic::EmptyMessage(lit.span));
+                    ctx.diagnostic(empty_message(lit.span));
                 }
             }
             Argument::TemplateLiteral(template_lit) => {
                 if template_lit.span.source_text(ctx.source_text()).len() == 2 {
-                    ctx.diagnostic(ErrorMessageDiagnostic::EmptyMessage(template_lit.span));
+                    ctx.diagnostic(empty_message(template_lit.span));
                 }
             }
             Argument::ObjectExpression(object_expr) => {
-                ctx.diagnostic(ErrorMessageDiagnostic::NotString(object_expr.span));
+                ctx.diagnostic(not_string(object_expr.span));
             }
             Argument::ArrayExpression(array_expr) => {
-                ctx.diagnostic(ErrorMessageDiagnostic::NotString(array_expr.span));
+                ctx.diagnostic(not_string(array_expr.span));
             }
             _ => {}
         }
diff --git a/crates/oxc_linter/src/rules/unicorn/escape_case.rs b/crates/oxc_linter/src/rules/unicorn/escape_case.rs
index 539fd7f4cd68..7a1b8f3cbad8 100644
--- a/crates/oxc_linter/src/rules/unicorn/escape_case.rs
+++ b/crates/oxc_linter/src/rules/unicorn/escape_case.rs
@@ -1,22 +1,19 @@
+use oxc_diagnostics::OxcDiagnostic;
+
 use std::str::Chars;
 
 use oxc_ast::{
     ast::{StringLiteral, TemplateLiteral},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(escape-case): Use uppercase characters for the value of the escape sequence.")]
-#[diagnostic(severity(warning))]
-struct EscapeCaseDiagnostic(#[label] pub Span);
+fn escape_case_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(escape-case): Use uppercase characters for the value of the escape sequence.").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct EscapeCase;
@@ -128,7 +125,9 @@ impl Rule for EscapeCase {
             AstKind::StringLiteral(StringLiteral { span, .. }) => {
                 let text = span.source_text(ctx.source_text());
                 if let Some(fixed) = check_case(text, false) {
-                    ctx.diagnostic_with_fix(EscapeCaseDiagnostic(*span), || Fix::new(fixed, *span));
+                    ctx.diagnostic_with_fix(escape_case_diagnostic(*span), || {
+                        Fix::new(fixed, *span)
+                    });
                 }
             }
             AstKind::TemplateLiteral(TemplateLiteral { quasis, .. }) => {
@@ -136,7 +135,7 @@ impl Rule for EscapeCase {
                     if let Some(fixed) =
                         check_case(quasi.span.source_text(ctx.source_text()), false)
                     {
-                        ctx.diagnostic_with_fix(EscapeCaseDiagnostic(quasi.span), || {
+                        ctx.diagnostic_with_fix(escape_case_diagnostic(quasi.span), || {
                             Fix::new(fixed, quasi.span)
                         });
                     }
@@ -145,7 +144,7 @@ impl Rule for EscapeCase {
             AstKind::RegExpLiteral(regex) => {
                 let text = regex.span.source_text(ctx.source_text());
                 if let Some(fixed) = check_case(text, true) {
-                    ctx.diagnostic_with_fix(EscapeCaseDiagnostic(regex.span), || {
+                    ctx.diagnostic_with_fix(escape_case_diagnostic(regex.span), || {
                         Fix::new(fixed, regex.span)
                     });
                 }
diff --git a/crates/oxc_linter/src/rules/unicorn/explicit_length_check.rs b/crates/oxc_linter/src/rules/unicorn/explicit_length_check.rs
index 94d3f3a8b903..7a20b6002614 100644
--- a/crates/oxc_linter/src/rules/unicorn/explicit_length_check.rs
+++ b/crates/oxc_linter/src/rules/unicorn/explicit_length_check.rs
@@ -1,16 +1,12 @@
-use miette::diagnostic;
 use oxc_ast::{
     ast::{
         BinaryExpression, Expression, LogicalExpression, MemberExpression, StaticMemberExpression,
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 use oxc_syntax::operator::{BinaryOperator, LogicalOperator};
 
 use crate::{
@@ -20,17 +16,22 @@ use crate::{
     AstNode, Fix,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum ExplicitLengthCheckDiagnostic {
-    #[error("eslint-plugin-unicorn(explicit-length-check): Use `.{1} {2}` when checking {1} is not zero.")]
-    #[diagnostic(severity(warning))]
-    NoneZero(#[label] Span, CompactStr, CompactStr, #[help] Option<String>),
-    #[error(
-        "eslint-plugin-unicorn(explicit-length-check): Use `.{1} {2}` when checking {1} is zero."
-    )]
-    #[diagnostic(severity(warning))]
-    Zero(#[label] Span, CompactStr, CompactStr, #[help] Option<String>),
+fn none_zero(span0: Span, x1: &str, x2: &str, x3: Option<String>) -> OxcDiagnostic {
+    let mut d = OxcDiagnostic::warning(format!("eslint-plugin-unicorn(explicit-length-check): Use `.{x1} {x2}` when checking {x1} is not zero.")).with_labels([span0.into()]);
+    if let Some(x) = x3 {
+        d = d.with_help(x);
+    }
+    d
 }
+
+fn zero(span0: Span, x1: &str, x2: &str, x3: Option<String>) -> OxcDiagnostic {
+    let mut d = OxcDiagnostic::warning(format!("eslint-plugin-unicorn(explicit-length-check): Use `.{x1} {x2}` when checking {x1} is zero."));
+    if let Some(x) = x3 {
+        d = d.with_help(x);
+    }
+    d.with_labels([span0.into()])
+}
+
 #[derive(Debug, Default, Clone)]
 enum NonZero {
     #[default]
@@ -216,10 +217,10 @@ impl ExplicitLengthCheck {
         );
         let property = static_member_expr.property.name.clone();
         let diagnostic = if is_zero_length_check {
-            ExplicitLengthCheckDiagnostic::Zero(
+            zero(
                 span,
-                property.to_compact_str(),
-                check_code.into(),
+                property.as_str(),
+                check_code,
                 if auto_fix {
                     None
                 } else {
@@ -227,10 +228,10 @@ impl ExplicitLengthCheck {
                 },
             )
         } else {
-            ExplicitLengthCheckDiagnostic::NoneZero(
+            none_zero(
                 span,
-                property.to_compact_str(),
-                check_code.into(),
+                property.as_str(),
+                check_code,
                 if auto_fix {
                     None
                 } else {
@@ -378,58 +379,30 @@ fn test() {
             ) {}",
             None,
         ),
-        (
-            "if ( foo.length || !!foo.length || foo.length != 0 || foo.length > 0 || foo.length >= 1 || 0 !== foo.length || 0 != foo.length || 0 < foo.length || 1 <= foo.length ) {}",
-            "if ( foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 ) {}",
-            Some(serde_json::json!([{"non-zero": "not-equal"}]))
-        ),
-        (
-            "const foo = { length: 123 }; if (foo.length) {}",
-            "const foo = { length: 123 }; if (foo.length !== 0) {}",
-            Some(serde_json::json!([{"non-zero": "not-equal"}]))
-        ),
+        ("if ( foo.length || !!foo.length || foo.length != 0 || foo.length > 0 || foo.length >= 1 || 0 !== foo.length || 0 != foo.length || 0 < foo.length || 1 <= foo.length ) {}", "if ( foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 || foo.length !== 0 ) {}", Some(serde_json::json!([{"non-zero": "not-equal"}]))),
+        ("const foo = { length: 123 }; if (foo.length) {}", "const foo = { length: 123 }; if (foo.length !== 0) {}", Some(serde_json::json!([{"non-zero": "not-equal"}]))),
         ("if (foo.bar && foo.bar.length) {}", "if (foo.bar && foo.bar.length > 0) {}", None),
         ("if (foo.length || foo.bar()) {}", "if (foo.length > 0 || foo.bar()) {}", None),
         ("if (!!(!!foo.length)) {}", "if (foo.length > 0) {}", None),
         ("if (!(foo.length === 0)) {}", "if (foo.length > 0) {}", None),
         ("while (foo.length >= 1) {}", "while (foo.length > 0) {}", None),
         ("do {} while (foo.length);", "do {} while (foo.length > 0);", None),
-        (
-            "for (let i = 0; (bar && !foo.length); i ++) {}",
-            "for (let i = 0; (bar && foo.length === 0); i ++) {}",
-            None,
-        ),
+        ("for (let i = 0; (bar && !foo.length); i ++) {}", "for (let i = 0; (bar && foo.length === 0); i ++) {}", None),
         ("const isEmpty = foo.length < 1;", "const isEmpty = foo.length === 0;", None),
         ("bar(foo.length >= 1)", "bar(foo.length > 0)", None),
         // ("const bar = void !foo.length;", "const bar = void (foo.length === 0);", None),
         ("const isNotEmpty = Boolean(foo.length)", "const isNotEmpty = foo.length > 0", None),
-        (
-            "const isNotEmpty = Boolean(foo.length || bar)",
-            "const isNotEmpty = Boolean(foo.length > 0 || bar)",
-            None,
-        ),
+        ("const isNotEmpty = Boolean(foo.length || bar)", "const isNotEmpty = Boolean(foo.length > 0 || bar)", None),
         ("const isEmpty = Boolean(!foo.length)", "const isEmpty = foo.length === 0", None),
         ("const isEmpty = Boolean(foo.length === 0)", "const isEmpty = foo.length === 0", None),
-        (
-            "const isNotEmpty = !Boolean(foo.length === 0)",
-            "const isNotEmpty = foo.length > 0",
-            None,
-        ),
-        (
-            "const isEmpty = !Boolean(!Boolean(foo.length === 0))",
-            "const isEmpty = foo.length === 0",
-            None,
-        ),
+        ("const isNotEmpty = !Boolean(foo.length === 0)", "const isNotEmpty = foo.length > 0", None),
+        ("const isEmpty = !Boolean(!Boolean(foo.length === 0))", "const isEmpty = foo.length === 0", None),
         ("if (foo.size) {}", "if (foo.size > 0) {}", None),
         ("if (foo.size && bar.length) {}", "if (foo.size > 0 && bar.length > 0) {}", None),
         // Space after keywords
         ("function foo() {return!foo.length}", "function foo() {return foo.length === 0}", None),
         ("function foo() {throw!foo.length}", "function foo() {throw foo.length === 0}", None),
-        (
-            "async function foo() {await!foo.length}",
-            "async function foo() {await (foo.length === 0)}",
-            None,
-        ),
+        ("async function foo() {await!foo.length}", "async function foo() {await (foo.length === 0)}", None),
         ("function * foo() {yield!foo.length}", "function * foo() {yield foo.length === 0}", None),
         ("function * foo() {yield*!foo.length}", "function * foo() {yield*foo.length === 0}", None),
         ("delete!foo.length", "delete (foo.length === 0)", None),
diff --git a/crates/oxc_linter/src/rules/unicorn/filename_case.rs b/crates/oxc_linter/src/rules/unicorn/filename_case.rs
index 098ce84398bc..e389a4c241a6 100644
--- a/crates/oxc_linter/src/rules/unicorn/filename_case.rs
+++ b/crates/oxc_linter/src/rules/unicorn/filename_case.rs
@@ -1,18 +1,18 @@
 use convert_case::{Case, Casing};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use serde_json::Value;
 
 use crate::{context::LintContext, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(filename-case): Filename should not be in {1} case")]
-#[diagnostic(severity(warning))]
-struct FilenameCaseDiagnostic(#[label] pub Span, &'static str);
+fn filename_case_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(filename-case): Filename should not be in {x1} case"
+    ))
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Clone)]
 #[allow(clippy::struct_field_names)]
@@ -96,7 +96,9 @@ impl Rule for FilenameCase {
     }
 
     fn run_once<'a>(&self, ctx: &LintContext<'_>) {
-        let Some(filename) = ctx.file_path().file_stem().and_then(|s| s.to_str()) else { return };
+        let Some(filename) = ctx.file_path().file_stem().and_then(|s| s.to_str()) else {
+            return;
+        };
 
         let mut case_name = None;
 
@@ -118,7 +120,7 @@ impl Rule for FilenameCase {
         }
 
         if let Some(case_name) = case_name {
-            ctx.diagnostic(FilenameCaseDiagnostic(Span::default(), case_name));
+            ctx.diagnostic(filename_case_diagnostic(Span::default(), case_name));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/new_for_builtins.rs b/crates/oxc_linter/src/rules/unicorn/new_for_builtins.rs
index e6eb93618445..a73ee3690ac1 100644
--- a/crates/oxc_linter/src/rules/unicorn/new_for_builtins.rs
+++ b/crates/oxc_linter/src/rules/unicorn/new_for_builtins.rs
@@ -2,10 +2,7 @@ use oxc_ast::{
     ast::{match_member_expression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::BinaryOperator;
@@ -13,14 +10,18 @@ use phf::phf_set;
 
 use crate::{context::LintContext, globals::GLOBAL_OBJECT_NAMES, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NewForBuiltinsDiagnostic {
-    #[error("eslint-plugin-unicorn(new-for-builtins): Use `new {1}()` instead of `{1}()`")]
-    #[diagnostic(severity(warning))]
-    Enforce(#[label] Span, String),
-    #[error("eslint-plugin-unicorn(new-for-builtins): Use `{1}()` instead of `new {1}()`")]
-    #[diagnostic(severity(warning))]
-    Disallow(#[label] Span, String),
+fn enforce(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(new-for-builtins): Use `new {x1}()` instead of `{x1}()`"
+    ))
+    .with_labels([span0.into()])
+}
+
+fn disallow(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(new-for-builtins): Use `{x1}()` instead of `new {x1}()`"
+    ))
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -60,13 +61,12 @@ impl Rule for NewForBuiltins {
             AstKind::NewExpression(new_expr) => {
                 let callee = new_expr.callee.without_parenthesized();
 
-                let Some(builtin_name) = is_expr_global_builtin(callee, ctx) else { return };
+                let Some(builtin_name) = is_expr_global_builtin(callee, ctx) else {
+                    return;
+                };
 
                 if DISALLOW_NEW_FOR_BUILTINS.contains(builtin_name) {
-                    ctx.diagnostic(NewForBuiltinsDiagnostic::Disallow(
-                        new_expr.span,
-                        builtin_name.to_string(),
-                    ));
+                    ctx.diagnostic(disallow(new_expr.span, builtin_name));
                 }
             }
             AstKind::CallExpression(call_expr) => {
@@ -89,10 +89,7 @@ impl Rule for NewForBuiltins {
                         }
                     }
 
-                    ctx.diagnostic(NewForBuiltinsDiagnostic::Enforce(
-                        call_expr.span,
-                        builtin_name.to_string(),
-                    ));
+                    ctx.diagnostic(enforce(call_expr.span, builtin_name));
                 }
             }
             _ => {}
@@ -113,13 +110,15 @@ fn is_expr_global_builtin<'a, 'b>(
         }
         match_member_expression!(Expression) => {
             let member_expr = expr.to_member_expression();
-            let Expression::Identifier(ident) = member_expr.object() else { return None };
+            let Expression::Identifier(ident) = member_expr.object() else {
+                return None;
+            };
 
             if !GLOBAL_OBJECT_NAMES.contains(ident.name.as_str()) {
                 return None;
             }
 
-            return member_expr.static_property_name();
+            member_expr.static_property_name()
         }
         _ => None,
     }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_abusive_eslint_disable.rs b/crates/oxc_linter/src/rules/unicorn/no_abusive_eslint_disable.rs
index 5851ba18a96f..ac48bca4c937 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_abusive_eslint_disable.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_abusive_eslint_disable.rs
@@ -1,16 +1,15 @@
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, disable_directives::DisableRuleComment, rule::Rule};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-abusive-eslint-disable): Unexpected `eslint-disable` comment that does not specify any rules to disable.")]
-#[diagnostic(severity(warning), help("Specify the rules you want to disable."))]
-struct NoAbusiveEslintDisableDiagnostic(#[label] pub Span);
+fn no_abusive_eslint_disable_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-abusive-eslint-disable): Unexpected `eslint-disable` comment that does not specify any rules to disable.")
+        .with_help("Specify the rules you want to disable.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAbusiveEslintDisable;
@@ -49,12 +48,12 @@ declare_oxc_lint!(
 impl Rule for NoAbusiveEslintDisable {
     fn run_once(&self, ctx: &LintContext) {
         for span in ctx.disable_directives().disable_all_comments() {
-            ctx.diagnostic(NoAbusiveEslintDisableDiagnostic(*span));
+            ctx.diagnostic(no_abusive_eslint_disable_diagnostic(*span));
         }
 
         for DisableRuleComment { span, rules } in ctx.disable_directives().disable_rule_comments() {
             if rules.is_empty() || !is_valid_rule_name(rules[0]) {
-                ctx.diagnostic(NoAbusiveEslintDisableDiagnostic(*span));
+                ctx.diagnostic(no_abusive_eslint_disable_diagnostic(*span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_array_for_each.rs b/crates/oxc_linter/src/rules/unicorn/no_array_for_each.rs
index 3f153251745d..633f5530b645 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_array_for_each.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_array_for_each.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{match_member_expression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -13,10 +11,11 @@ use crate::{ast_util::is_method_call, context::LintContext, rule::Rule, AstNode}
 
 use phf::phf_set;
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-array-for-each): Do not use `Array#forEach`")]
-#[diagnostic(severity(warning), help("Replace it with a for` loop. For loop is faster, more readable, and you can use `break` or `return` to exit early."))]
-struct NoArrayForEachDiagnostic(#[label] pub Span);
+fn no_array_for_each_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-array-for-each): Do not use `Array#forEach`")
+        .with_help("Replace it with a for` loop. For loop is faster, more readable, and you can use `break` or `return` to exit early.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoArrayForEach;
@@ -89,7 +88,7 @@ impl Rule for NoArrayForEach {
                 return;
             };
 
-            ctx.diagnostic(NoArrayForEachDiagnostic(span));
+            ctx.diagnostic(no_array_for_each_diagnostic(span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_array_reduce.rs b/crates/oxc_linter/src/rules/unicorn/no_array_reduce.rs
index 9367a24fa587..abd06a9e8072 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_array_reduce.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_array_reduce.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -14,10 +12,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-array-reduce): Don't use `Array#reduce()` and `Array#reduceRight()`, use `for` loops instead.")]
-#[diagnostic(severity(warning), help("Refactor your code to use `for` loops instead."))]
-struct NoArrayReduceDiagnostic(#[label] pub Span);
+fn no_array_reduce_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-array-reduce): Don't use `Array#reduce()` and `Array#reduceRight()`, use `for` loops instead.")
+        .with_help("Refactor your code to use `for` loops instead.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Clone)]
 pub struct NoArrayReduce {
@@ -80,7 +79,7 @@ impl Rule for NoArrayReduce {
             if self.allow_simple_operations && is_simple_operation(call_expr) {
                 return;
             }
-            ctx.diagnostic(NoArrayReduceDiagnostic(span));
+            ctx.diagnostic(no_array_reduce_diagnostic(span));
         }
 
         if let Some(member_expr_obj) = member_expr.object().as_member_expression() {
@@ -92,7 +91,7 @@ impl Rule for NoArrayReduce {
                 && (is_prototype_property(member_expr_obj, "reduce", Some("Array"))
                     || is_prototype_property(member_expr_obj, "reduceRight", Some("Array")))
             {
-                ctx.diagnostic(NoArrayReduceDiagnostic(span));
+                ctx.diagnostic(no_array_reduce_diagnostic(span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_await_expression_member.rs b/crates/oxc_linter/src/rules/unicorn/no_await_expression_member.rs
index 159fe83abc21..1ae2d1317611 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_await_expression_member.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_await_expression_member.rs
@@ -1,17 +1,16 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-await-expression-member): Disallow member access from await expression")]
-#[diagnostic(severity(warning), help("When accessing a member from an await expression, the await expression has to be parenthesized, which is not readable."))]
-struct NoAwaitExpressionMemberDiagnostic(#[label] pub Span);
+fn no_await_expression_member_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-await-expression-member): Disallow member access from await expression")
+        .with_help("When accessing a member from an await expression, the await expression has to be parenthesized, which is not readable.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAwaitExpressionMember;
@@ -40,7 +39,9 @@ declare_oxc_lint!(
 
 impl Rule for NoAwaitExpressionMember {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::MemberExpression(member_expr) = node.kind() else { return };
+        let AstKind::MemberExpression(member_expr) = node.kind() else {
+            return;
+        };
 
         let Expression::ParenthesizedExpression(paren_expr) = member_expr.object() else {
             return;
@@ -48,7 +49,7 @@ impl Rule for NoAwaitExpressionMember {
 
         if matches!(paren_expr.expression, Expression::AwaitExpression(_)) {
             let node_span = member_expr.span();
-            ctx.diagnostic(NoAwaitExpressionMemberDiagnostic(node_span));
+            ctx.diagnostic(no_await_expression_member_diagnostic(node_span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_await_in_promise_methods.rs b/crates/oxc_linter/src/rules/unicorn/no_await_in_promise_methods.rs
index 4d537a208e97..8e56ff6b04fd 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_await_in_promise_methods.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_await_in_promise_methods.rs
@@ -1,17 +1,16 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{ast_util::is_method_call, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-await-in-promise-methods): Promise in `Promise.{1}()` should not be awaited.")]
-#[diagnostic(severity(warning), help("Remove the `await`"))]
-struct NoAwaitInPromiseMethodsDiagnostic(#[label] pub Span, String);
+fn no_await_in_promise_methods_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(no-await-in-promise-methods): Promise in `Promise.{x1}()` should not be awaited."))
+        .with_help("Remove the `await`")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoAwaitInPromiseMethods;
@@ -83,9 +82,9 @@ impl Rule for NoAwaitInPromiseMethods {
                         .static_property_name()
                         .expect("callee is a static property");
 
-                    ctx.diagnostic(NoAwaitInPromiseMethodsDiagnostic(
+                    ctx.diagnostic(no_await_in_promise_methods_diagnostic(
                         Span::new(await_expr.span.start, await_expr.span.start + 5),
-                        property_name.to_string(),
+                        property_name,
                     ));
                 }
             }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_console_spaces.rs b/crates/oxc_linter/src/rules/unicorn/no_console_spaces.rs
index 54c7ffcc65d4..14285aa49234 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_console_spaces.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_console_spaces.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -13,12 +11,11 @@ use crate::{
     AstNode, Fix,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-unicorn(no-console-spaces): Do not use {0} spaces with `console.{1}` parameters"
-)]
-#[diagnostic(severity(warning), help("The `console.log()` method and similar methods join the parameters with a space so adding a leading/trailing space to a parameter, results in two spaces being added."))]
-struct NoConsoleSpacesDiagnostic(&'static str, String, #[label] pub Span);
+fn no_console_spaces_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(no-console-spaces): Do not use {x0} spaces with `console.{x1}` parameters"))
+        .with_help("The `console.log()` method and similar methods join the parameters with a space so adding a leading/trailing space to a parameter, results in two spaces being added.")
+        .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoConsoleSpaces;
@@ -48,7 +45,9 @@ declare_oxc_lint!(
 
 impl Rule for NoConsoleSpaces {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
         if !is_method_call(
             call_expr,
@@ -134,7 +133,7 @@ fn report_diagnostic(
         literal_raw.trim().to_string()
     };
 
-    ctx.diagnostic_with_fix(NoConsoleSpacesDiagnostic(direction, ident.to_string(), span), || {
+    ctx.diagnostic_with_fix(no_console_spaces_diagnostic(direction, ident, span), || {
         Fix::new(fix, Span::new(start, end))
     });
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_document_cookie.rs b/crates/oxc_linter/src/rules/unicorn/no_document_cookie.rs
index 37fc88211550..639751e318bb 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_document_cookie.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_document_cookie.rs
@@ -2,10 +2,8 @@ use oxc_ast::{
     ast::{match_member_expression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -14,10 +12,13 @@ use crate::{
     rule::Rule, AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-document-cookie): Do not use `document.cookie` directly")]
-#[diagnostic(severity(warning), help("Use the Cookie Store API or a cookie library instead"))]
-struct NoDocumentCookieDiagnostic(#[label] pub Span);
+fn no_document_cookie_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(no-document-cookie): Do not use `document.cookie` directly",
+    )
+    .with_help("Use the Cookie Store API or a cookie library instead")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoDocumentCookie;
@@ -75,7 +76,7 @@ impl Rule for NoDocumentCookie {
             return;
         }
 
-        ctx.diagnostic(NoDocumentCookieDiagnostic(assignment_expr.left.span()));
+        ctx.diagnostic(no_document_cookie_diagnostic(assignment_expr.left.span()));
     }
 }
 
@@ -104,7 +105,9 @@ fn is_document_cookie_reference<'a, 'b>(
         }
         match_member_expression!(Expression) => {
             let member_expr = expr.to_member_expression();
-            let Some(static_prop_name) = member_expr.static_property_name() else { return false };
+            let Some(static_prop_name) = member_expr.static_property_name() else {
+                return false;
+            };
             if static_prop_name != "document" {
                 return false;
             }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs b/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs
index 987a4508f6b5..35ea7eaba9a0 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_empty_file.rs
@@ -1,8 +1,6 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -10,10 +8,11 @@ use crate::{
     context::LintContext, partial_loader::LINT_PARTIAL_LOADER_EXT, rule::Rule, utils::is_empty_stmt,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-empty-file): Empty files are not allowed.")]
-#[diagnostic(severity(warning), help("Delete this file or add some code to it."))]
-struct NoEmptyFileDiagnostic(#[label] pub Span);
+fn no_empty_file_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-empty-file): Empty files are not allowed.")
+        .with_help("Delete this file or add some code to it.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoEmptyFile;
@@ -47,7 +46,9 @@ impl Rule for NoEmptyFile {
         {
             return;
         }
-        let Some(root) = ctx.nodes().root_node() else { return };
+        let Some(root) = ctx.nodes().root_node() else {
+            return;
+        };
         let AstKind::Program(program) = root.kind() else { unreachable!() };
 
         if program.body.iter().any(|node| !is_empty_stmt(node)) {
@@ -58,7 +59,7 @@ impl Rule for NoEmptyFile {
             return;
         }
 
-        ctx.diagnostic(NoEmptyFileDiagnostic(Span::new(0, 0)));
+        ctx.diagnostic(no_empty_file_diagnostic(Span::new(0, 0)));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/no_hex_escape.rs b/crates/oxc_linter/src/rules/unicorn/no_hex_escape.rs
index 905b4f52e9ea..d80635fbfafe 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_hex_escape.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_hex_escape.rs
@@ -2,21 +2,19 @@ use oxc_ast::{
     ast::{StringLiteral, TemplateLiteral},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-unicorn(no-hex-escape): Use Unicode escapes instead of hexadecimal escapes."
-)]
-#[diagnostic(severity(warning))]
-struct NoHexEscapeDiagnostic(#[label] pub Span);
+fn no_hex_escape_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(no-hex-escape): Use Unicode escapes instead of hexadecimal escapes.",
+    )
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoHexEscape;
@@ -75,7 +73,7 @@ impl Rule for NoHexEscape {
             AstKind::StringLiteral(StringLiteral { span, .. }) => {
                 let text = span.source_text(ctx.source_text());
                 if let Some(fixed) = check_escape(&text[1..text.len() - 1]) {
-                    ctx.diagnostic_with_fix(NoHexEscapeDiagnostic(*span), || {
+                    ctx.diagnostic_with_fix(no_hex_escape_diagnostic(*span), || {
                         Fix::new(format!("'{fixed}'"), *span)
                     });
                 }
@@ -83,7 +81,7 @@ impl Rule for NoHexEscape {
             AstKind::TemplateLiteral(TemplateLiteral { quasis, .. }) => {
                 quasis.iter().for_each(|quasi| {
                     if let Some(fixed) = check_escape(quasi.span.source_text(ctx.source_text())) {
-                        ctx.diagnostic_with_fix(NoHexEscapeDiagnostic(quasi.span), || {
+                        ctx.diagnostic_with_fix(no_hex_escape_diagnostic(quasi.span), || {
                             Fix::new(fixed, quasi.span)
                         });
                     }
@@ -92,7 +90,7 @@ impl Rule for NoHexEscape {
             AstKind::RegExpLiteral(regex) => {
                 let text = regex.span.source_text(ctx.source_text());
                 if let Some(fixed) = check_escape(&text[1..text.len() - 1]) {
-                    ctx.diagnostic_with_fix(NoHexEscapeDiagnostic(regex.span), || {
+                    ctx.diagnostic_with_fix(no_hex_escape_diagnostic(regex.span), || {
                         Fix::new(format!("/{fixed}/"), regex.span)
                     });
                 }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_instanceof_array.rs b/crates/oxc_linter/src/rules/unicorn/no_instanceof_array.rs
index b13beda79f80..8925dbe842d7 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_instanceof_array.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_instanceof_array.rs
@@ -1,19 +1,18 @@
 use oxc_ast::ast::Expression;
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::BinaryOperator;
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-instanceof-array): Use `Array.isArray()` instead of `instanceof Array`.")]
-#[diagnostic(severity(warning), help("The instanceof Array check doesn't work across realms/contexts, for example, frames/windows in browsers or the vm module in Node.js."))]
-struct NoInstanceofArrayDiagnostic(#[label] pub Span);
+fn no_instanceof_array_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-instanceof-array): Use `Array.isArray()` instead of `instanceof Array`.")
+        .with_help("The instanceof Array check doesn't work across realms/contexts, for example, frames/windows in browsers or the vm module in Node.js.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoInstanceofArray;
@@ -36,14 +35,16 @@ declare_oxc_lint!(
 
 impl Rule for NoInstanceofArray {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::BinaryExpression(expr) = node.kind() else { return };
+        let AstKind::BinaryExpression(expr) = node.kind() else {
+            return;
+        };
         if expr.operator != BinaryOperator::Instanceof {
             return;
         }
 
         match &expr.right.without_parenthesized() {
             Expression::Identifier(identifier) if identifier.name == "Array" => {
-                ctx.diagnostic_with_fix(NoInstanceofArrayDiagnostic(expr.span), || {
+                ctx.diagnostic_with_fix(no_instanceof_array_diagnostic(expr.span), || {
                     let modified_code = {
                         let mut codegen = String::new();
                         codegen.push_str("Array.isArray(");
diff --git a/crates/oxc_linter/src/rules/unicorn/no_invalid_remove_event_listener.rs b/crates/oxc_linter/src/rules/unicorn/no_invalid_remove_event_listener.rs
index e413b49c1f3e..09c4da4e8690 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_invalid_remove_event_listener.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_invalid_remove_event_listener.rs
@@ -2,24 +2,18 @@ use oxc_ast::{
     ast::{Argument, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-unicorn(no-invalid-remove-event-listener): Invalid `removeEventListener` call."
-)]
-#[diagnostic(severity(warning), help("The listener argument should be a function reference."))]
-struct NoInvalidRemoveEventListenerDiagnostic(
-    #[label("`removeEventListener` called here.")] pub Span,
-    #[label("Invalid argument here")] pub Span,
-);
+fn no_invalid_remove_event_listener_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-invalid-remove-event-listener): Invalid `removeEventListener` call.")
+        .with_help("The listener argument should be a function reference.")
+        .with_labels([LabeledSpan::new_with_span(Some("`removeEventListener` called here.".into()), span0), LabeledSpan::new_with_span(Some("Invalid argument here".into()), span1)])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoInvalidRemoveEventListener;
@@ -49,13 +43,17 @@ declare_oxc_lint!(
 
 impl Rule for NoInvalidRemoveEventListener {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
         if call_expr.optional {
             return;
         }
 
-        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
 
         let remove_event_listener_ident_span = match member_expr {
             MemberExpression::StaticMemberExpression(v) => {
@@ -75,7 +73,9 @@ impl Rule for NoInvalidRemoveEventListener {
             return;
         }
 
-        let Some(listener) = call_expr.arguments.get(1) else { return };
+        let Some(listener) = call_expr.arguments.get(1) else {
+            return;
+        };
 
         if !matches!(
             listener,
@@ -115,7 +115,7 @@ impl Rule for NoInvalidRemoveEventListener {
             listener_span
         };
 
-        ctx.diagnostic(NoInvalidRemoveEventListenerDiagnostic(
+        ctx.diagnostic(no_invalid_remove_event_listener_diagnostic(
             remove_event_listener_ident_span,
             listener_span,
         ));
diff --git a/crates/oxc_linter/src/rules/unicorn/no_lonely_if.rs b/crates/oxc_linter/src/rules/unicorn/no_lonely_if.rs
index 4dcf7f6bc531..f18a5cabea43 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_lonely_if.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_lonely_if.rs
@@ -1,17 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-lonely-if): Unexpected `if` as the only statement in a `if` block without `else`.")]
-#[diagnostic(severity(warning), help("Move the inner `if` test to the outer `if` test."))]
-struct NoLonelyIfDiagnostic(#[label] pub Span, #[label] pub Span);
+fn no_lonely_if_diagnostic(span0: Span, span1: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-lonely-if): Unexpected `if` as the only statement in a `if` block without `else`.")
+        .with_help("Move the inner `if` test to the outer `if` test.")
+        .with_labels([span0.into(), span1.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoLonelyIf;
@@ -45,7 +44,9 @@ declare_oxc_lint!(
 
 impl Rule for NoLonelyIf {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::IfStatement(if_stmt) = node.kind() else { return };
+        let AstKind::IfStatement(if_stmt) = node.kind() else {
+            return;
+        };
 
         if if_stmt.alternate.is_some() {
             return;
@@ -84,7 +85,7 @@ impl Rule for NoLonelyIf {
             _ => return,
         };
 
-        ctx.diagnostic(NoLonelyIfDiagnostic(
+        ctx.diagnostic(no_lonely_if_diagnostic(
             Span::new(if_stmt.span.start, if_stmt.span.start + 2),
             Span::new(parent_if_stmt_span.start, parent_if_stmt_span.start + 2),
         ));
diff --git a/crates/oxc_linter/src/rules/unicorn/no_negated_condition.rs b/crates/oxc_linter/src/rules/unicorn/no_negated_condition.rs
index b5bb6afa8176..1d1034041ce0 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_negated_condition.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_negated_condition.rs
@@ -2,23 +2,21 @@ use oxc_ast::{
     ast::{Expression, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{BinaryOperator, UnaryOperator};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-negated-condition): Unexpected negated condition.")]
-#[diagnostic(
-    severity(warning),
-    help("Remove the negation operator and switch the consequent and alternate branches.")
-)]
-struct NoNegatedConditionDiagnostic(#[label] pub Span);
+fn no_negated_condition_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(no-negated-condition): Unexpected negated condition.",
+    )
+    .with_help("Remove the negation operator and switch the consequent and alternate branches.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoNegatedCondition;
@@ -62,7 +60,9 @@ impl Rule for NoNegatedCondition {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         let stmt_test = match node.kind() {
             AstKind::IfStatement(if_stmt) => {
-                let Some(if_stmt_alternate) = &if_stmt.alternate else { return };
+                let Some(if_stmt_alternate) = &if_stmt.alternate else {
+                    return;
+                };
 
                 if matches!(if_stmt_alternate, Statement::IfStatement(_)) {
                     return;
@@ -97,7 +97,7 @@ impl Rule for NoNegatedCondition {
             }
         }
 
-        ctx.diagnostic(NoNegatedConditionDiagnostic(stmt_test.span()));
+        ctx.diagnostic(no_negated_condition_diagnostic(stmt_test.span()));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/no_nested_ternary.rs b/crates/oxc_linter/src/rules/unicorn/no_nested_ternary.rs
index 496602e8267e..f0e0a40a9a18 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_nested_ternary.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_nested_ternary.rs
@@ -1,26 +1,22 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoNestedTernaryDiagnostic {
-    #[error("eslint-plugin-unicorn(no-nested-ternary): Unexpected nested ternary expression without parentheses.")]
-    #[diagnostic(severity(warning), help("Add parentheses around the nested ternary expression."))]
-    UnparenthesizedNestedTernary(#[label] Span),
-    #[error(
-        "eslint-plugin-unicorn(no-nested-ternary): Unexpected deeply nested ternary expression."
-    )]
-    #[diagnostic(
-        severity(warning),
-        help("Avoid nesting ternary expressions for more than one level.")
-    )]
-    DeeplyNestedTernary(#[label] Span),
+fn unparenthesized_nested_ternary(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-nested-ternary): Unexpected nested ternary expression without parentheses.")
+        .with_help("Add parentheses around the nested ternary expression.")
+        .with_labels([span0.into()])
+}
+
+fn deeply_nested_ternary(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(no-nested-ternary): Unexpected deeply nested ternary expression.",
+    )
+    .with_help("Avoid nesting ternary expressions for more than one level.")
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -50,7 +46,9 @@ declare_oxc_lint!(
 
 impl Rule for NoNestedTernary {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::ConditionalExpression(cond_expr) = node.kind() else { return };
+        let AstKind::ConditionalExpression(cond_expr) = node.kind() else {
+            return;
+        };
 
         if matches!(&cond_expr.test.get_inner_expression(), Expression::ConditionalExpression(_))
             || matches!(
@@ -88,18 +86,15 @@ impl Rule for NoNestedTernary {
                 if let AstKind::ParenthesizedExpression(_) = parent_node.kind() {
                     return;
                 }
-                ctx.diagnostic_with_fix(
-                    NoNestedTernaryDiagnostic::UnparenthesizedNestedTernary(cond_expr.span),
-                    || {
-                        Fix::new(
-                            format!("({})", cond_expr.span.source_text(ctx.source_text())),
-                            cond_expr.span,
-                        )
-                    },
-                );
+                ctx.diagnostic_with_fix(unparenthesized_nested_ternary(cond_expr.span), || {
+                    Fix::new(
+                        format!("({})", cond_expr.span.source_text(ctx.source_text())),
+                        cond_expr.span,
+                    )
+                });
             }
             2 => {
-                ctx.diagnostic(NoNestedTernaryDiagnostic::DeeplyNestedTernary(cond_expr.span));
+                ctx.diagnostic(deeply_nested_ternary(cond_expr.span));
             }
             _ => unreachable!(),
         }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_new_array.rs b/crates/oxc_linter/src/rules/unicorn/no_new_array.rs
index 2c92285184aa..5442868df333 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_new_array.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_new_array.rs
@@ -1,17 +1,14 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-new-array): Do not use `new Array(singleArgument)`.")]
-#[diagnostic(severity(warning), help(r#"It's not clear whether the argument is meant to be the length of the array or the only element. If the argument is the array's length, consider using `Array.from({{ length: n }})`. If the argument is the only element, use `[element]`."#))]
-struct NoNewArrayDiagnostic(#[label] pub Span);
+fn no_new_array_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-new-array): Do not use `new Array(singleArgument)`.").with_help(r"It's not clear whether the argument is meant to be the length of the array or the only element. If the argument is the array's length, consider using `Array.from({ length: n })`. If the argument is the only element, use `[element]`.").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoNewArray;
@@ -42,9 +39,13 @@ declare_oxc_lint!(
 
 impl Rule for NoNewArray {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::NewExpression(new_expr) = node.kind() else { return };
+        let AstKind::NewExpression(new_expr) = node.kind() else {
+            return;
+        };
 
-        let Expression::Identifier(ident) = &new_expr.callee else { return };
+        let Expression::Identifier(ident) = &new_expr.callee else {
+            return;
+        };
 
         if ident.name != "Array" {
             return;
@@ -54,7 +55,7 @@ impl Rule for NoNewArray {
             return;
         }
 
-        ctx.diagnostic(NoNewArrayDiagnostic(new_expr.span));
+        ctx.diagnostic(no_new_array_diagnostic(new_expr.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/no_new_buffer.rs b/crates/oxc_linter/src/rules/unicorn/no_new_buffer.rs
index 9b538b1bcadb..07779772e389 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_new_buffer.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_new_buffer.rs
@@ -1,20 +1,16 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-new-buffer): Use `Buffer.alloc()` or `Buffer.from()` instead of the deprecated `new Buffer()` constructor.")]
-#[diagnostic(
-    severity(warning),
-    help("`new Buffer()` is deprecated, use `Buffer.alloc()` or `Buffer.from()` instead.")
-)]
-struct NoNewBufferDiagnostic(#[label] pub Span);
+fn no_new_buffer_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-new-buffer): Use `Buffer.alloc()` or `Buffer.from()` instead of the deprecated `new Buffer()` constructor.")
+        .with_help("`new Buffer()` is deprecated, use `Buffer.alloc()` or `Buffer.from()` instead.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoNewBuffer;
@@ -42,7 +38,9 @@ declare_oxc_lint!(
 
 impl Rule for NoNewBuffer {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::NewExpression(new_expr) = node.kind() else { return };
+        let AstKind::NewExpression(new_expr) = node.kind() else {
+            return;
+        };
 
         let Expression::Identifier(ident) = &new_expr.callee.without_parenthesized() else {
             return;
@@ -50,7 +48,7 @@ impl Rule for NoNewBuffer {
         if ident.name != "Buffer" {
             return;
         }
-        ctx.diagnostic(NoNewBufferDiagnostic(ident.span));
+        ctx.diagnostic(no_new_buffer_diagnostic(ident.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/no_null.rs b/crates/oxc_linter/src/rules/unicorn/no_null.rs
index fb5e158b0b29..0566a22895d6 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_null.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_null.rs
@@ -4,25 +4,25 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::BinaryOperator;
 
 use crate::{ast_util::is_method_call, context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-null): Disallow the use of the `null` literal")]
-#[diagnostic(severity(warning), help("Replace the `null` literal with `undefined`."))]
-struct ReplaceNullDiagnostic(#[label] pub Span);
+fn replace_null_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-null): Disallow the use of the `null` literal")
+        .with_help("Replace the `null` literal with `undefined`.")
+        .with_labels([span0.into()])
+}
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-null): Disallow the use of the `null` literal")]
-#[diagnostic(severity(warning), help("Remove the `null` literal."))]
-struct RemoveNullDiagnostic(#[label] pub Span);
+fn remove_null_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-null): Disallow the use of the `null` literal")
+        .with_help("Remove the `null` literal.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoNull {
@@ -81,7 +81,7 @@ fn diagnose_binary_expression(
 
     // `if (foo != null) {}`
     if matches!(binary_expr.operator, BinaryOperator::Equality | BinaryOperator::Inequality) {
-        ctx.diagnostic_with_fix(ReplaceNullDiagnostic(null_literal.span), || {
+        ctx.diagnostic_with_fix(replace_null_diagnostic(null_literal.span), || {
             Fix::new("undefined", null_literal.span)
         });
 
@@ -89,7 +89,7 @@ fn diagnose_binary_expression(
     }
 
     // checkStrictEquality=true && `if (foo !== null) {}`
-    ctx.diagnostic_with_fix(ReplaceNullDiagnostic(null_literal.span), || {
+    ctx.diagnostic_with_fix(replace_null_diagnostic(null_literal.span), || {
         Fix::new("undefined", null_literal.span)
     });
 }
@@ -104,7 +104,7 @@ fn diagnose_variable_declarator(
     if matches!(&variable_declarator.init, Some(Expression::NullLiteral(expr)) if expr.span == null_literal.span)
         && matches!(parent_kind, Some(AstKind::VariableDeclaration(var_declaration)) if !var_declaration.kind.is_const() )
     {
-        ctx.diagnostic_with_fix(RemoveNullDiagnostic(null_literal.span), || {
+        ctx.diagnostic_with_fix(remove_null_diagnostic(null_literal.span), || {
             Fix::delete(Span::new(variable_declarator.id.span().end, null_literal.span.end))
         });
 
@@ -112,7 +112,7 @@ fn diagnose_variable_declarator(
     }
 
     // `const foo = null`
-    ctx.diagnostic_with_fix(ReplaceNullDiagnostic(null_literal.span), || {
+    ctx.diagnostic_with_fix(replace_null_diagnostic(null_literal.span), || {
         Fix::new("undefined", null_literal.span)
     });
 }
@@ -201,7 +201,7 @@ impl Rule for NoNull {
 
             // `function foo() { return null; }`,
             if matches!(parent_node.kind(), AstKind::ReturnStatement(_)) {
-                ctx.diagnostic_with_fix(RemoveNullDiagnostic(null_literal.span), || {
+                ctx.diagnostic_with_fix(remove_null_diagnostic(null_literal.span), || {
                     Fix::delete(null_literal.span)
                 });
 
@@ -209,7 +209,7 @@ impl Rule for NoNull {
             }
         }
 
-        ctx.diagnostic_with_fix(ReplaceNullDiagnostic(null_literal.span), || {
+        ctx.diagnostic_with_fix(replace_null_diagnostic(null_literal.span), || {
             Fix::new("undefined", null_literal.span)
         });
     }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_object_as_default_parameter.rs b/crates/oxc_linter/src/rules/unicorn/no_object_as_default_parameter.rs
index d4764fe55ca6..cd972295b96d 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_object_as_default_parameter.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_object_as_default_parameter.rs
@@ -2,23 +2,18 @@ use oxc_ast::{
     ast::{BindingPatternKind, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoObjectAsDefaultParameterDiagnostic {
-    #[error("eslint-plugin-unicorn(no-object-as-default-parameter): Do not use an object literal as default for parameter `{1}`.")]
-    #[diagnostic(severity(warning))]
-    Identifier(#[label] Span, String),
-    #[error("eslint-plugin-unicorn(no-object-as-default-parameter): Do not use an object literal as default")]
-    #[diagnostic(severity(warning))]
-    NonIdentifier(#[label] Span),
+fn identifier(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(no-object-as-default-parameter): Do not use an object literal as default for parameter `{x1}`.")).with_labels([span0.into()])
+}
+
+fn non_identifier(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-object-as-default-parameter): Do not use an object literal as default").with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -47,7 +42,9 @@ declare_oxc_lint!(
 
 impl Rule for NoObjectAsDefaultParameter {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::AssignmentPattern(assignment_pat) = node.kind() else { return };
+        let AstKind::AssignmentPattern(assignment_pat) = node.kind() else {
+            return;
+        };
 
         let Expression::ObjectExpression(object_expr) =
             &assignment_pat.right.without_parenthesized()
@@ -59,21 +56,20 @@ impl Rule for NoObjectAsDefaultParameter {
             return;
         }
 
-        let Some(parent) = ctx.nodes().parent_node(node.id()) else { return };
+        let Some(parent) = ctx.nodes().parent_node(node.id()) else {
+            return;
+        };
 
         if !matches!(parent.kind(), AstKind::FormalParameter(_)) {
             return;
         }
 
         if let BindingPatternKind::BindingIdentifier(binding_id) = &assignment_pat.left.kind {
-            ctx.diagnostic(NoObjectAsDefaultParameterDiagnostic::Identifier(
-                object_expr.span,
-                binding_id.name.to_string(),
-            ));
+            ctx.diagnostic(identifier(object_expr.span, &binding_id.name));
             return;
         }
 
-        ctx.diagnostic(NoObjectAsDefaultParameterDiagnostic::NonIdentifier(object_expr.span));
+        ctx.diagnostic(non_identifier(object_expr.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/no_process_exit.rs b/crates/oxc_linter/src/rules/unicorn/no_process_exit.rs
index 5c9fafabea78..799df5edd960 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_process_exit.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_process_exit.rs
@@ -1,20 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{ast_util::is_method_call, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-process-exit): Disallow `process.exit()`.")]
-#[diagnostic(
-    severity(warning),
-    help("Only use `process.exit()` in CLI apps. Throw an error instead.")
-)]
-struct NoProcessExitDiagnostic(#[label] pub Span);
+fn no_process_exit_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-process-exit): Disallow `process.exit()`.")
+        .with_help("Only use `process.exit()` in CLI apps. Throw an error instead.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoProcessExit;
@@ -52,14 +48,16 @@ impl Rule for NoProcessExit {
                     return;
                 }
 
-                ctx.diagnostic(NoProcessExitDiagnostic(expr.span));
+                ctx.diagnostic(no_process_exit_diagnostic(expr.span));
             }
         }
     }
 }
 
 fn has_hashbang(ctx: &LintContext) -> bool {
-    let Some(root) = ctx.nodes().root_node() else { return false };
+    let Some(root) = ctx.nodes().root_node() else {
+        return false;
+    };
     let AstKind::Program(program) = root.kind() else { unreachable!() };
     program.hashbang.is_some()
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_single_promise_in_promise_methods.rs b/crates/oxc_linter/src/rules/unicorn/no_single_promise_in_promise_methods.rs
index 1799e2a43d13..e5cc95ff1006 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_single_promise_in_promise_methods.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_single_promise_in_promise_methods.rs
@@ -2,22 +2,18 @@ use oxc_ast::{
     ast::{CallExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{ast_util::is_method_call, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-single-promise-in-promise-methods): Wrapping single-element array with `Promise.{1}()` is unnecessary.")]
-#[diagnostic(
-    severity(warning),
-    help("Either use the value directly, or switch to `Promise.resolve(…)`.")
-)]
-struct NoSinglePromiseInPromiseMethodsDiagnostic(#[label] Span, pub String);
+fn no_single_promise_in_promise_methods_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(no-single-promise-in-promise-methods): Wrapping single-element array with `Promise.{x1}()` is unnecessary."))
+        .with_help("Either use the value directly, or switch to `Promise.resolve(…)`.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoSinglePromiseInPromiseMethods;
@@ -72,7 +68,7 @@ impl Rule for NoSinglePromiseInPromiseMethods {
             .static_property_info()
             .expect("callee is a static property");
 
-        ctx.diagnostic(NoSinglePromiseInPromiseMethodsDiagnostic(info.0, info.1.to_string()));
+        ctx.diagnostic(no_single_promise_in_promise_methods_diagnostic(info.0, info.1));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/no_static_only_class.rs b/crates/oxc_linter/src/rules/unicorn/no_static_only_class.rs
index a54ef876834d..36e95bad3785 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_static_only_class.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_static_only_class.rs
@@ -1,22 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-unicorn(no-static-only-class): Disallow classes that only have static members."
-)]
-#[diagnostic(
-    severity(warning),
-    help("A class with only static members could just be an object instead.")
-)]
-struct NoStaticOnlyClassDiagnostic(#[label] pub Span);
+fn no_static_only_class_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-static-only-class): Disallow classes that only have static members.")
+        .with_help("A class with only static members could just be an object instead.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoStaticOnlyClass;
@@ -51,7 +45,9 @@ declare_oxc_lint!(
 
 impl Rule for NoStaticOnlyClass {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::Class(class) = node.kind() else { return };
+        let AstKind::Class(class) = node.kind() else {
+            return;
+        };
 
         if class.super_class.is_some() {
             return;
@@ -90,7 +86,7 @@ impl Rule for NoStaticOnlyClass {
             return;
         }
 
-        ctx.diagnostic(NoStaticOnlyClassDiagnostic(class.span));
+        ctx.diagnostic(no_static_only_class_diagnostic(class.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/no_thenable.rs b/crates/oxc_linter/src/rules/unicorn/no_thenable.rs
index 3811380b2b10..4122f8c6c58e 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_thenable.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_thenable.rs
@@ -6,26 +6,28 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoThenableDiagnostic {
-    #[error("eslint-plugin-unicorn(no-thenable): Do not add `then` to an object.")]
-    #[diagnostic(severity(warning), help("If an object is defined as 'thenable', once it's accidentally used in an await expression, it may cause problems"))]
-    Object(#[label] Span),
-    #[error("eslint-plugin-unicorn(no-thenable): Do not export `then`.")]
-    #[diagnostic(severity(warning), help("If an object is defined as 'thenable', once it's accidentally used in an await expression, it may cause problems"))]
-    Export(#[label] Span),
-    #[error("eslint-plugin-unicorn(no-thenable): Do not add `then` to a class.")]
-    #[diagnostic(severity(warning), help("If an object is defined as 'thenable', once it's accidentally used in an await expression, it may cause problems"))]
-    Class(#[label] Span),
+fn object(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-thenable): Do not add `then` to an object.")
+        .with_help("If an object is defined as 'thenable', once it's accidentally used in an await expression, it may cause problems")
+        .with_labels([span0.into()])
+}
+
+fn export(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-thenable): Do not export `then`.")
+        .with_help("If an object is defined as 'thenable', once it's accidentally used in an await expression, it may cause problems")
+        .with_labels([span0.into()])
+}
+
+fn class(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-thenable): Do not add `then` to a class.")
+        .with_help("If an object is defined as 'thenable', once it's accidentally used in an await expression, it may cause problems")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -62,19 +64,19 @@ impl Rule for NoThenable {
                 expr.properties.iter().for_each(|prop| {
                     if let ObjectPropertyKind::ObjectProperty(prop) = prop {
                         if let Some(span) = contains_then(&prop.key, ctx) {
-                            ctx.diagnostic(NoThenableDiagnostic::Object(span));
+                            ctx.diagnostic(object(span));
                         }
                     }
                 });
             }
             AstKind::PropertyDefinition(def) => {
                 if let Some(span) = contains_then(&def.key, ctx) {
-                    ctx.diagnostic(NoThenableDiagnostic::Class(span));
+                    ctx.diagnostic(class(span));
                 }
             }
             AstKind::MethodDefinition(def) => {
                 if let Some(span) = contains_then(&def.key, ctx) {
-                    ctx.diagnostic(NoThenableDiagnostic::Class(span));
+                    ctx.diagnostic(class(span));
                 }
             }
             AstKind::ModuleDeclaration(ModuleDeclaration::ExportNamedDeclaration(decl)) => {
@@ -89,14 +91,14 @@ impl Rule for NoThenable {
                         Declaration::FunctionDeclaration(decl) => {
                             if let Some(bind) = decl.id.as_ref() {
                                 if bind.name == "then" {
-                                    ctx.diagnostic(NoThenableDiagnostic::Export(bind.span));
+                                    ctx.diagnostic(export(bind.span));
                                 }
                             };
                         }
                         Declaration::ClassDeclaration(decl) => {
                             if let Some(bind) = decl.id.as_ref() {
                                 if bind.name == "then" {
-                                    ctx.diagnostic(NoThenableDiagnostic::Export(bind.span));
+                                    ctx.diagnostic(export(bind.span));
                                 }
                             };
                         }
@@ -108,12 +110,12 @@ impl Rule for NoThenable {
                     match spec.exported {
                         ModuleExportName::Identifier(ref ident) => {
                             if ident.name == "then" {
-                                ctx.diagnostic(NoThenableDiagnostic::Export(ident.span));
+                                ctx.diagnostic(export(ident.span));
                             }
                         }
                         ModuleExportName::StringLiteral(ref lit) => {
                             if lit.value == "then" {
-                                ctx.diagnostic(NoThenableDiagnostic::Export(lit.span));
+                                ctx.diagnostic(export(lit.span));
                             }
                         }
                     }
@@ -124,12 +126,12 @@ impl Rule for NoThenable {
             AstKind::AssignmentExpression(AssignmentExpression { left, .. }) => match left {
                 AssignmentTarget::ComputedMemberExpression(expr) => {
                     if let Some(span) = check_expression(&expr.expression, ctx) {
-                        ctx.diagnostic(NoThenableDiagnostic::Class(span));
+                        ctx.diagnostic(class(span));
                     }
                 }
                 AssignmentTarget::StaticMemberExpression(expr) => {
                     if expr.property.name == "then" {
-                        ctx.diagnostic(NoThenableDiagnostic::Class(expr.span));
+                        ctx.diagnostic(class(expr.span));
                     }
                 }
                 _ => {}
@@ -158,7 +160,7 @@ fn check_call_expression(expr: &CallExpression, ctx: &LintContext) {
     } {
     } else if let Some(inner) = expr.arguments[1].as_expression() {
         if let Some(span) = check_expression(inner, ctx) {
-            ctx.diagnostic(NoThenableDiagnostic::Object(span));
+            ctx.diagnostic(object(span));
         }
     }
 
@@ -187,7 +189,7 @@ fn check_call_expression(expr: &CallExpression, ctx: &LintContext) {
                 {
                     if let Some(expr) = inner.elements[0].as_expression() {
                         if let Some(span) = check_expression(expr, ctx) {
-                            ctx.diagnostic(NoThenableDiagnostic::Object(span));
+                            ctx.diagnostic(object(span));
                         }
                     }
                 }
@@ -200,7 +202,7 @@ fn check_binding_pattern(pat: &BindingPatternKind, ctx: &LintContext) {
     match pat {
         BindingPatternKind::BindingIdentifier(bind) => {
             if bind.name == "then" {
-                ctx.diagnostic(NoThenableDiagnostic::Export(bind.span));
+                ctx.diagnostic(export(bind.span));
             }
         }
         BindingPatternKind::ObjectPattern(obj) => {
diff --git a/crates/oxc_linter/src/rules/unicorn/no_this_assignment.rs b/crates/oxc_linter/src/rules/unicorn/no_this_assignment.rs
index df61126e8931..f21cf90d8466 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_this_assignment.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_this_assignment.rs
@@ -2,22 +2,20 @@ use oxc_ast::{
     ast::{AssignmentTarget, BindingPatternKind, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-this-assignment): Do not assign `this` to `{1}`")]
-#[diagnostic(
-    severity(warning),
-    help("Reference `this` directly instead of assigning it to a variable.")
-)]
-struct NoThisAssignmentDiagnostic(#[label] pub Span, CompactStr);
+fn no_this_assignment_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(no-this-assignment): Do not assign `this` to `{x1}`"
+    ))
+    .with_help("Reference `this` directly instead of assigning it to a variable.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoThisAssignment;
@@ -76,9 +74,9 @@ impl Rule for NoThisAssignment {
                     return;
                 };
 
-                ctx.diagnostic(NoThisAssignmentDiagnostic(
+                ctx.diagnostic(no_this_assignment_diagnostic(
                     variable_decl.span,
-                    binding_ident.name.to_compact_str(),
+                    binding_ident.name.as_str(),
                 ));
             }
             AstKind::AssignmentExpression(assignment_expr) => {
@@ -94,9 +92,9 @@ impl Rule for NoThisAssignment {
                     return;
                 };
 
-                ctx.diagnostic(NoThisAssignmentDiagnostic(
+                ctx.diagnostic(no_this_assignment_diagnostic(
                     assignment_expr.span,
-                    ident.name.to_compact_str(),
+                    ident.name.as_str(),
                 ));
             }
             _ => {}
diff --git a/crates/oxc_linter/src/rules/unicorn/no_typeof_undefined.rs b/crates/oxc_linter/src/rules/unicorn/no_typeof_undefined.rs
index 3ab65f3afac7..4ab8f6f54eb1 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_typeof_undefined.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_typeof_undefined.rs
@@ -1,18 +1,15 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::{BinaryOperator, UnaryOperator};
 
 use crate::{ast_util::get_declaration_of_variable, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-typeof-undefined): Compare with `undefined` directly instead of using `typeof`.")]
-#[diagnostic(severity(warning))]
-struct NoTypeofUndefinedDiagnostic(#[label] pub Span);
+fn no_typeof_undefined_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-typeof-undefined): Compare with `undefined` directly instead of using `typeof`.").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoTypeofUndefined {
@@ -43,7 +40,9 @@ declare_oxc_lint!(
 
 impl Rule for NoTypeofUndefined {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::BinaryExpression(bin_expr) = node.kind() else { return };
+        let AstKind::BinaryExpression(bin_expr) = node.kind() else {
+            return;
+        };
 
         if !matches!(
             bin_expr.operator,
@@ -55,7 +54,9 @@ impl Rule for NoTypeofUndefined {
             return;
         }
 
-        let Expression::UnaryExpression(unary_expr) = &bin_expr.left else { return };
+        let Expression::UnaryExpression(unary_expr) = &bin_expr.left else {
+            return;
+        };
 
         if unary_expr.operator != UnaryOperator::Typeof {
             return;
@@ -69,7 +70,7 @@ impl Rule for NoTypeofUndefined {
             return;
         }
 
-        ctx.diagnostic(NoTypeofUndefinedDiagnostic(bin_expr.span));
+        ctx.diagnostic(no_typeof_undefined_diagnostic(bin_expr.span));
     }
 
     fn from_configuration(value: serde_json::Value) -> Self {
@@ -81,7 +82,9 @@ impl Rule for NoTypeofUndefined {
 }
 
 fn is_global_variable(ident: &Expression, ctx: &LintContext) -> bool {
-    let Expression::Identifier(ident) = ident else { return false };
+    let Expression::Identifier(ident) = ident else {
+        return false;
+    };
 
     get_declaration_of_variable(ident, ctx).is_none()
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_unnecessary_await.rs b/crates/oxc_linter/src/rules/unicorn/no_unnecessary_await.rs
index 5b71141fa220..8f6c13cde477 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_unnecessary_await.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_unnecessary_await.rs
@@ -1,17 +1,18 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-unnecessary-await): Disallow awaiting non-promise values")]
-#[diagnostic(severity(warning), help("consider to remove the `await`"))]
-struct NoUnnecessaryAwaitDiagnostic(#[label] pub Span);
+fn no_unnecessary_await_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(no-unnecessary-await): Disallow awaiting non-promise values",
+    )
+    .with_help("consider to remove the `await`")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnnecessaryAwait;
@@ -55,13 +56,16 @@ impl Rule for NoUnnecessaryAwait {
                     }
                 })
             } {
-                ctx.diagnostic(NoUnnecessaryAwaitDiagnostic(Span::new(
+                ctx.diagnostic(no_unnecessary_await_diagnostic(Span::new(
                     expr.span.start,
                     expr.span.start + 5,
                 )));
             } else {
                 ctx.diagnostic_with_fix(
-                    NoUnnecessaryAwaitDiagnostic(Span::new(expr.span.start, expr.span.start + 5)),
+                    no_unnecessary_await_diagnostic(Span::new(
+                        expr.span.start,
+                        expr.span.start + 5,
+                    )),
                     || {
                         let mut codegen = String::new();
                         codegen.push_str(expr.argument.span().source_text(ctx.source_text()));
diff --git a/crates/oxc_linter/src/rules/unicorn/no_unreadable_array_destructuring.rs b/crates/oxc_linter/src/rules/unicorn/no_unreadable_array_destructuring.rs
index 334c409f5c1d..4f04f98fdbc0 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_unreadable_array_destructuring.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_unreadable_array_destructuring.rs
@@ -1,21 +1,17 @@
 use oxc_allocator::Vec;
 use oxc_ast::{ast::AssignmentTarget, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-unreadable-array-destructuring): Disallow unreadable array destructuring")]
-#[diagnostic(
-    severity(warning),
-    help("Array destructuring may not contain consecutive ignored values.")
-)]
-struct NoUnreadableArrayDestructuringDiagnostic(#[label] pub Span);
+fn no_unreadable_array_destructuring_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-unreadable-array-destructuring): Disallow unreadable array destructuring")
+        .with_help("Array destructuring may not contain consecutive ignored values.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnreadableArrayDestructuring;
@@ -58,7 +54,7 @@ impl Rule for NoUnreadableArrayDestructuring {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::ArrayPattern(array_pattern) = node.kind() {
             if is_unreadable_array_destructuring(&array_pattern.elements, &array_pattern.rest) {
-                ctx.diagnostic(NoUnreadableArrayDestructuringDiagnostic(array_pattern.span));
+                ctx.diagnostic(no_unreadable_array_destructuring_diagnostic(array_pattern.span));
             }
         }
 
@@ -66,7 +62,7 @@ impl Rule for NoUnreadableArrayDestructuring {
             node.kind()
         {
             if is_unreadable_array_destructuring(&array_pattern.elements, &array_pattern.rest) {
-                ctx.diagnostic(NoUnreadableArrayDestructuringDiagnostic(array_pattern.span));
+                ctx.diagnostic(no_unreadable_array_destructuring_diagnostic(array_pattern.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_unreadable_iife.rs b/crates/oxc_linter/src/rules/unicorn/no_unreadable_iife.rs
index fb1809345fa1..1d21e9b9f9cf 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_unreadable_iife.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_unreadable_iife.rs
@@ -2,22 +2,18 @@ use oxc_ast::{
     ast::{Expression, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-unreadable-iife): IIFE with parenthesized arrow function body is considered unreadable.")]
-#[diagnostic(
-    severity(warning),
-    help("Rewrite the IIFE to avoid having a parenthesized arrow function body.")
-)]
-struct NoUnreadableIifeDiagnostic(#[label] pub Span);
+fn no_unreadable_iife_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-unreadable-iife): IIFE with parenthesized arrow function body is considered unreadable.")
+        .with_help("Rewrite the IIFE to avoid having a parenthesized arrow function body.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUnreadableIife;
@@ -53,7 +49,9 @@ declare_oxc_lint!(
 
 impl Rule for NoUnreadableIife {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
         let Expression::ArrowFunctionExpression(arrow_expr) =
             &call_expr.callee.without_parenthesized()
@@ -68,7 +66,7 @@ impl Rule for NoUnreadableIife {
             return;
         };
         if matches!(expr_stmt.expression, Expression::ParenthesizedExpression(_)) {
-            ctx.diagnostic(NoUnreadableIifeDiagnostic(expr_stmt.span));
+            ctx.diagnostic(no_unreadable_iife_diagnostic(expr_stmt.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_useless_fallback_in_spread.rs b/crates/oxc_linter/src/rules/unicorn/no_useless_fallback_in_spread.rs
index e63dbff975ec..c8311f1676c1 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_useless_fallback_in_spread.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_useless_fallback_in_spread.rs
@@ -1,18 +1,17 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::LogicalOperator;
 
 use crate::{ast_util::outermost_paren_parent, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-useless-fallback-in-spread): Disallow useless fallback when spreading in object literals")]
-#[diagnostic(severity(warning), help("Spreading falsy values in object literals won't add any unexpected properties, so it's unnecessary to add an empty object as fallback."))]
-struct NoUselessFallbackInSpreadDiagnostic(#[label] pub Span);
+fn no_useless_fallback_in_spread_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-useless-fallback-in-spread): Disallow useless fallback when spreading in object literals")
+        .with_help("Spreading falsy values in object literals won't add any unexpected properties, so it's unnecessary to add an empty object as fallback.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUselessFallbackInSpread;
@@ -42,7 +41,9 @@ declare_oxc_lint!(
 
 impl Rule for NoUselessFallbackInSpread {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::LogicalExpression(logical_expression) = node.kind() else { return };
+        let AstKind::LogicalExpression(logical_expression) = node.kind() else {
+            return;
+        };
 
         if !matches!(logical_expression.operator, LogicalOperator::Or | LogicalOperator::Coalesce) {
             return;
@@ -58,17 +59,23 @@ impl Rule for NoUselessFallbackInSpread {
             return;
         }
 
-        let Some(parent) = outermost_paren_parent(node, ctx) else { return };
+        let Some(parent) = outermost_paren_parent(node, ctx) else {
+            return;
+        };
 
-        let AstKind::SpreadElement(spread_element) = parent.kind() else { return };
+        let AstKind::SpreadElement(spread_element) = parent.kind() else {
+            return;
+        };
 
-        let Some(parent) = outermost_paren_parent(parent, ctx) else { return };
+        let Some(parent) = outermost_paren_parent(parent, ctx) else {
+            return;
+        };
 
         if !matches!(parent.kind(), AstKind::ObjectExpression(_)) {
             return;
         }
 
-        ctx.diagnostic(NoUselessFallbackInSpreadDiagnostic(spread_element.span));
+        ctx.diagnostic(no_useless_fallback_in_spread_diagnostic(spread_element.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/no_useless_length_check.rs b/crates/oxc_linter/src/rules/unicorn/no_useless_length_check.rs
index 40c90e72213b..5b44cdcc95ca 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_useless_length_check.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_useless_length_check.rs
@@ -1,8 +1,6 @@
 use itertools::concat;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::{BinaryOperator, LogicalOperator};
@@ -15,22 +13,20 @@ use oxc_ast::{
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoUselessLengthCheckDiagnostic {
-    #[error("eslint-plugin-unicorn(no-useless-length-check)")]
-    #[diagnostic(
-        severity(warning),
-        help(
-            "The non-empty check is useless as `Array#some()` returns `false` for an empty array."
+fn some(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-useless-length-check)")
+        .with_help(
+            "The non-empty check is useless as `Array#some()` returns `false` for an empty array.",
+        )
+        .with_labels([span0.into()])
+}
+
+fn every(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-useless-length-check)")
+        .with_help(
+            "The empty check is useless as `Array#every()` returns `true` for an empty array.",
         )
-    )]
-    Some(#[label] Span),
-    #[error("eslint-plugin-unicorn(no-useless-length-check)")]
-    #[diagnostic(
-        severity(warning),
-        help("The empty check is useless as `Array#every()` returns `true` for an empty array.")
-    )]
-    Every(#[label] Span),
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -66,7 +62,7 @@ fn is_useless_check<'a>(
     left: &'a Expression<'a>,
     right: &'a Expression<'a>,
     operator: LogicalOperator,
-) -> Option<NoUselessLengthCheckDiagnostic> {
+) -> Option<OxcDiagnostic> {
     let every_condition = ConditionDTO {
         property_name: "every",
         binary_operators: vec![BinaryOperator::StrictEquality],
@@ -144,9 +140,9 @@ fn is_useless_check<'a>(
 
     if l && r {
         Some(if active_condition.property_name == "every" {
-            NoUselessLengthCheckDiagnostic::Every(binary_expression_span?)
+            every(binary_expression_span?)
         } else {
-            NoUselessLengthCheckDiagnostic::Some(binary_expression_span?)
+            some(binary_expression_span?)
         })
     } else {
         None
diff --git a/crates/oxc_linter/src/rules/unicorn/no_useless_promise_resolve_reject.rs b/crates/oxc_linter/src/rules/unicorn/no_useless_promise_resolve_reject.rs
index 0b8cc5792ecb..3661bf0629a3 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_useless_promise_resolve_reject.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_useless_promise_resolve_reject.rs
@@ -1,21 +1,20 @@
 use oxc_ast::{ast::MemberExpression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{ast_util::outermost_paren_parent, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoUselessPromiseResolveRejectDiagnostic {
-    #[error("eslint-plugin-unicorn(no-useless-promise-resolve-reject): Prefer `{1} value` over `{1} Promise.resolve(value)`.")]
-    #[diagnostic(severity(warning), help("Wrapping the return value in `Promise.Resolve` is needlessly verbose. All return values in async functions are already wrapped in a `Promise`."))]
-    Resolve(#[label] Span, &'static str),
-    #[error("eslint-plugin-unicorn(no-useless-promise-resolve-reject): Prefer `throw error` over `{1} Promise.reject(error)`.")]
-    #[diagnostic(severity(warning), help("Wrapping the error in `Promise.reject` is needlessly verbose. All errors thrown in async functions are already wrapped in a `Promise`."))]
-    Reject(#[label] Span, &'static str),
+fn resolve(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(no-useless-promise-resolve-reject): Prefer `{x1} value` over `{x1} Promise.resolve(value)`."))
+        .with_help("Wrapping the return value in `Promise.Resolve` is needlessly verbose. All return values in async functions are already wrapped in a `Promise`.")
+        .with_labels([span0.into()])
+}
+
+fn reject(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(no-useless-promise-resolve-reject): Prefer `throw error` over `{x1} Promise.reject(error)`."))
+        .with_help("Wrapping the error in `Promise.reject` is needlessly verbose. All errors thrown in async functions are already wrapped in a `Promise`.")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -44,8 +43,12 @@ declare_oxc_lint!(
 
 impl Rule for NoUselessPromiseResolveReject {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
-        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
 
         if !member_expr.object().is_specific_id("Promise") {
             return;
@@ -72,7 +75,9 @@ impl Rule for NoUselessPromiseResolveReject {
             }
         }
 
-        let Some((is_async, function_node)) = get_function_like_node(node, ctx) else { return };
+        let Some((is_async, function_node)) = get_function_like_node(node, ctx) else {
+            return;
+        };
 
         if !(is_async || is_promise_callback(function_node, ctx)) {
             return;
@@ -80,13 +85,13 @@ impl Rule for NoUselessPromiseResolveReject {
 
         match static_member_expr.property.name.as_str() {
             "resolve" => {
-                ctx.diagnostic(NoUselessPromiseResolveRejectDiagnostic::Resolve(
+                ctx.diagnostic(resolve(
                     node.kind().span(),
                     if is_yield { "yield" } else { "return" },
                 ));
             }
             "reject" => {
-                ctx.diagnostic(NoUselessPromiseResolveRejectDiagnostic::Reject(
+                ctx.diagnostic(reject(
                     node.kind().span(),
                     if is_yield { "yield" } else { "return" },
                 ));
@@ -129,14 +134,20 @@ fn is_promise_callback<'a, 'b>(node: &'a AstNode<'b>, ctx: &'a LintContext<'b>)
         return false;
     };
 
-    let AstKind::CallExpression(call_expr) = parent.kind() else { return false };
+    let AstKind::CallExpression(call_expr) = parent.kind() else {
+        return false;
+    };
 
-    let Some(member_expr) = call_expr.callee.get_member_expr() else { return false };
+    let Some(member_expr) = call_expr.callee.get_member_expr() else {
+        return false;
+    };
 
     if member_expr.is_computed() {
         return false;
     }
-    let Some(static_prop_name) = member_expr.static_property_name() else { return false };
+    let Some(static_prop_name) = member_expr.static_property_name() else {
+        return false;
+    };
 
     if call_expr.arguments.len() == 1 && matches!(static_prop_name, "then" | "catch" | "finally") {
         return true;
@@ -318,7 +329,7 @@ fn test() {
         r"
 			async function foo() {
 				return Promise.reject(bar);
-		    }   
+		    }
 		",
         r"
 			(async function() {
diff --git a/crates/oxc_linter/src/rules/unicorn/no_useless_spread.rs b/crates/oxc_linter/src/rules/unicorn/no_useless_spread.rs
index 974b694ca0aa..ac1a434535a1 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_useless_spread.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_useless_spread.rs
@@ -5,10 +5,8 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -21,32 +19,38 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoUselessSpreadDiagnostic {
-    #[error("eslint-plugin-unicorn(no-useless-spread): Using a spread operator here creates a new {1} unnecessarily.")]
-    #[diagnostic(severity(warning), help("Consider removing the spread operator."))]
-    SpreadInList(#[label] Span, &'static str),
-    #[error("eslint-plugin-unicorn(no-useless-spread): Using a spread operator here creates a new array unnecessarily.")]
-    #[diagnostic(severity(warning), help("This function accepts a rest parameter, it's unnecessary to create a new array and then spread it. Instead, supply the arguments directly.\nFor example, replace `foo(...[1, 2, 3])` with `foo(1, 2, 3)`."))]
-    SpreadInArguments(#[label] Span),
-    #[error("eslint-plugin-unicorn(no-useless-spread): `{1}` accepts an iterable, so it's unnecessary to convert the iterable to an array.")]
-    #[diagnostic(severity(warning), help("Consider removing the spread operator."))]
-    IterableToArray(#[label] Span, String),
-    #[error("eslint-plugin-unicorn(no-useless-spread): Using a spread operator here creates a new array unnecessarily.")]
-    #[diagnostic(
-        severity(warning),
-        help("`for…of` can iterate over iterable, it's unnecessary to convert to an array.")
-    )]
-    IterableToArrayInForOf(#[label] Span),
-    #[error("eslint-plugin-unicorn(no-useless-spread): Using a spread operator here creates a new array unnecessarily.")]
-    #[diagnostic(severity(warning), help("`yield*` can delegate to another iterable, so it's unnecessary to convert the iterable to an array."))]
-    IterableToArrayInYieldStar(#[label] Span),
-    #[error("eslint-plugin-unicorn(no-useless-spread): Using a spread operator here creates a new array unnecessarily.")]
-    #[diagnostic(
-        severity(warning),
-        help("`{1}` returns a new array. Spreading it into an array expression to create a new array is redundant.")
-    )]
-    CloneArray(#[label] Span, String),
+fn spread_in_list(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(no-useless-spread): Using a spread operator here creates a new {x1} unnecessarily."))
+        .with_help("Consider removing the spread operator.")
+        .with_labels([span0.into()])
+}
+
+fn spread_in_arguments(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-useless-spread): Using a spread operator here creates a new array unnecessarily.").with_help("This function accepts a rest parameter, it's unnecessary to create a new array and then spread it. Instead, supply the arguments directly.\nFor example, replace `foo(...[1, 2, 3])` with `foo(1, 2, 3)`.").with_labels([span0.into()])
+}
+
+fn iterable_to_array(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(no-useless-spread): `{x1}` accepts an iterable, so it's unnecessary to convert the iterable to an array."))
+        .with_help("Consider removing the spread operator.")
+        .with_labels([span0.into()])
+}
+
+fn iterable_to_array_in_for_of(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-useless-spread): Using a spread operator here creates a new array unnecessarily.")
+        .with_help("`for…of` can iterate over iterable, it's unnecessary to convert to an array.")
+        .with_labels([span0.into()])
+}
+
+fn iterable_to_array_in_yield_star(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-useless-spread): Using a spread operator here creates a new array unnecessarily.")
+        .with_help("`yield*` can delegate to another iterable, so it's unnecessary to convert the iterable to an array.")
+        .with_labels([span0.into()])
+}
+
+fn clone_array(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(no-useless-spread): Using a spread operator here creates a new array unnecessarily.")
+        .with_help(format!("`{x1}` returns a new array. Spreading it into an array expression to create a new array is redundant."))
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -152,17 +156,17 @@ fn check_useless_spread_in_list<'a>(node: &AstNode<'a>, ctx: &LintContext<'a>) {
                 AstKind::ObjectExpression(_) => {
                     // { ...{ } }
                     if matches!(parent_parent.kind(), AstKind::ObjectExpression(_)) {
-                        ctx.diagnostic(NoUselessSpreadDiagnostic::SpreadInList(span, "object"));
+                        ctx.diagnostic(spread_in_list(span, "object"));
                     }
                 }
                 AstKind::ArrayExpression(_) => match parent_parent.kind() {
                     // ...[ ]
                     AstKind::ArrayExpressionElement(_) => {
-                        ctx.diagnostic(NoUselessSpreadDiagnostic::SpreadInList(span, "array"));
+                        ctx.diagnostic(spread_in_list(span, "array"));
                     }
                     // foo(...[ ])
                     AstKind::Argument(_) => {
-                        ctx.diagnostic(NoUselessSpreadDiagnostic::SpreadInArguments(span));
+                        ctx.diagnostic(spread_in_arguments(span));
                     }
                     _ => {}
                 },
@@ -179,7 +183,9 @@ fn check_useless_iterable_to_array<'a>(
     array_expr: &ArrayExpression<'a>,
     ctx: &LintContext<'a>,
 ) {
-    let Some(parent) = outermost_paren_parent(node, ctx) else { return };
+    let Some(parent) = outermost_paren_parent(node, ctx) else {
+        return;
+    };
 
     if !is_single_array_spread(array_expr) {
         return;
@@ -203,14 +209,14 @@ fn check_useless_iterable_to_array<'a>(
     match parent.kind() {
         AstKind::ForOfStatement(for_of_stmt) => {
             if for_of_stmt.right.without_parenthesized().span() == array_expr.span {
-                ctx.diagnostic(NoUselessSpreadDiagnostic::IterableToArrayInForOf(span));
+                ctx.diagnostic(iterable_to_array_in_for_of(span));
             }
         }
         AstKind::YieldExpression(yield_expr) => {
             if yield_expr.delegate
                 && yield_expr.argument.as_ref().is_some_and(|arg| arg.span() == array_expr.span)
             {
-                ctx.diagnostic(NoUselessSpreadDiagnostic::IterableToArrayInYieldStar(span));
+                ctx.diagnostic(iterable_to_array_in_yield_star(span));
             }
         }
 
@@ -241,9 +247,9 @@ fn check_useless_iterable_to_array<'a>(
             {
                 return;
             }
-            ctx.diagnostic(NoUselessSpreadDiagnostic::IterableToArray(
+            ctx.diagnostic(iterable_to_array(
                 span,
-                get_new_expr_ident_name(new_expr).unwrap_or("unknown").into(),
+                get_new_expr_ident_name(new_expr).unwrap_or("unknown"),
             ));
         }
         AstKind::CallExpression(call_expr) => {
@@ -283,9 +289,9 @@ fn check_useless_iterable_to_array<'a>(
                 return;
             }
 
-            ctx.diagnostic(NoUselessSpreadDiagnostic::IterableToArray(
+            ctx.diagnostic(iterable_to_array(
                 span,
-                get_method_name(call_expr).unwrap_or_else(|| "unknown".into()),
+                &get_method_name(call_expr).unwrap_or_else(|| "unknown".into()),
             ));
         }
         _ => {}
@@ -343,7 +349,7 @@ fn check_useless_array_clone<'a>(array_expr: &ArrayExpression<'a>, ctx: &LintCon
             },
         );
 
-        ctx.diagnostic(NoUselessSpreadDiagnostic::CloneArray(span, method));
+        ctx.diagnostic(clone_array(span, &method));
     }
 
     if let Expression::AwaitExpression(await_expr) = &spread_elem.argument {
@@ -360,10 +366,7 @@ fn check_useless_array_clone<'a>(array_expr: &ArrayExpression<'a>, ctx: &LintCon
             let method_name =
                 call_expr.callee.get_member_expr().unwrap().static_property_name().unwrap();
 
-            ctx.diagnostic(NoUselessSpreadDiagnostic::CloneArray(
-                span,
-                format!("Promise.{method_name}"),
-            ));
+            ctx.diagnostic(clone_array(span, &format!("Promise.{method_name}")));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_useless_switch_case.rs b/crates/oxc_linter/src/rules/unicorn/no_useless_switch_case.rs
index 79ef371a5a3e..6e295a3535d2 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_useless_switch_case.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_useless_switch_case.rs
@@ -1,20 +1,18 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, utils::is_empty_stmt, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(no-useless-switch-case): Useless case in switch statement.")]
-#[diagnostic(
-    severity(warning),
-    help("Consider removing this case or removing the `default` case.")
-)]
-struct NoUselessSwitchCaseDiagnostic(#[label] pub Span);
+fn no_useless_switch_case_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(no-useless-switch-case): Useless case in switch statement.",
+    )
+    .with_help("Consider removing this case or removing the `default` case.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct NoUselessSwitchCase;
@@ -85,7 +83,7 @@ impl Rule for NoUselessSwitchCase {
         }
 
         for case in useless_cases {
-            ctx.diagnostic(NoUselessSwitchCaseDiagnostic(case.span));
+            ctx.diagnostic(no_useless_switch_case_diagnostic(case.span));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/no_zero_fractions.rs b/crates/oxc_linter/src/rules/unicorn/no_zero_fractions.rs
index a5a7955644f1..23efdb18bcf6 100644
--- a/crates/oxc_linter/src/rules/unicorn/no_zero_fractions.rs
+++ b/crates/oxc_linter/src/rules/unicorn/no_zero_fractions.rs
@@ -1,21 +1,24 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NoZeroFractionsDiagnostic {
-    #[error("eslint-plugin-unicorn(no-zero-fractions): Don't use a zero fraction in the number.")]
-    #[diagnostic(severity(warning), help("Replace the number literal with `{1}`"))]
-    ZeroFraction(#[label] Span, String),
-    #[error("eslint-plugin-unicorn(no-zero-fractions): Don't use a dangling dot in the number.")]
-    #[diagnostic(severity(warning), help("Replace the number literal with `{1}`"))]
-    DanglingDot(#[label] Span, String),
+fn zero_fraction(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(no-zero-fractions): Don't use a zero fraction in the number.",
+    )
+    .with_help(format!("Replace the number literal with `{x1}`"))
+    .with_labels([span0.into()])
+}
+
+fn dangling_dot(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(no-zero-fractions): Don't use a dangling dot in the number.",
+    )
+    .with_help(format!("Replace the number literal with `{x1}`"))
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -53,16 +56,18 @@ impl Rule for NoZeroFractions {
             return;
         };
 
-        let Some((fmt, is_dangling_dot)) = format_raw(number_literal.raw) else { return };
+        let Some((fmt, is_dangling_dot)) = format_raw(number_literal.raw) else {
+            return;
+        };
         if fmt == number_literal.raw {
             return;
         };
 
         ctx.diagnostic_with_fix(
             if is_dangling_dot {
-                NoZeroFractionsDiagnostic::DanglingDot(number_literal.span, fmt.clone())
+                dangling_dot(number_literal.span, &fmt)
             } else {
-                NoZeroFractionsDiagnostic::ZeroFraction(number_literal.span, fmt.clone())
+                zero_fraction(number_literal.span, &fmt)
             },
             || Fix::new(fmt, number_literal.span),
         );
diff --git a/crates/oxc_linter/src/rules/unicorn/number_literal_case.rs b/crates/oxc_linter/src/rules/unicorn/number_literal_case.rs
index ce47fa85d8d1..541a06c23c9c 100644
--- a/crates/oxc_linter/src/rules/unicorn/number_literal_case.rs
+++ b/crates/oxc_linter/src/rules/unicorn/number_literal_case.rs
@@ -1,33 +1,37 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-enum NumberLiteralCaseDiagnostic {
-    #[error("eslint-plugin-unicorn(number-literal-case): Unexpected number literal prefix in uppercase.")]
-    #[diagnostic(severity(warning), help("Use lowercase for the number literal prefix `{1}`."))]
-    UppercasePrefix(#[label] Span, &'static str),
-    #[error(
-        "eslint-plugin-unicorn(number-literal-case): Unexpected exponential notation in uppercase."
-    )]
-    #[diagnostic(severity(warning), help("Use lowercase for `e` in exponential notations."))]
-    UppercaseExponentialNotation(#[label] Span),
-    #[error(
-        "eslint-plugin-unicorn(number-literal-case): Unexpected hexadecimal digits in lowercase."
-    )]
-    #[diagnostic(severity(warning), help("Use uppercase for hexadecimal digits."))]
-    LowercaseHexadecimalDigits(#[label] Span),
-    #[error(
-        "eslint-plugin-unicorn(number-literal-case): Unexpected number literal prefix in uppercase and hexadecimal digits in lowercase."
-    )]
-    #[diagnostic(severity(warning), help("Use lowercase for the number literal prefix `{1}` and uppercase for hexadecimal digits."))]
-    UppercasePrefixAndLowercaseHexadecimalDigits(#[label] Span, &'static str),
+fn uppercase_prefix(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(number-literal-case): Unexpected number literal prefix in uppercase.")
+        .with_help(format!("Use lowercase for the number literal prefix `{x1}`."))
+        .with_labels([span0.into()])
+}
+
+fn uppercase_exponential_notation(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(number-literal-case): Unexpected exponential notation in uppercase.",
+    )
+    .with_help("Use lowercase for `e` in exponential notations.")
+    .with_labels([span0.into()])
+}
+
+fn lowercase_hexadecimal_digits(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(number-literal-case): Unexpected hexadecimal digits in lowercase.",
+    )
+    .with_help("Use uppercase for hexadecimal digits.")
+    .with_labels([span0.into()])
+}
+
+fn uppercase_prefix_and_lowercase_hexadecimal_digits(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(number-literal-case): Unexpected number literal prefix in uppercase and hexadecimal digits in lowercase.")
+        .with_help(format!("Use lowercase for the number literal prefix `{x1}` and uppercase for hexadecimal digits."))
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -85,13 +89,10 @@ impl Rule for NumberLiteralCase {
 }
 
 #[allow(clippy::cast_possible_truncation)]
-fn check_number_literal(
-    number_literal: &str,
-    raw_span: Span,
-) -> Option<(NumberLiteralCaseDiagnostic, String)> {
+fn check_number_literal(number_literal: &str, raw_span: Span) -> Option<(OxcDiagnostic, String)> {
     if number_literal.starts_with("0B") || number_literal.starts_with("0O") {
         return Some((
-            NumberLiteralCaseDiagnostic::UppercasePrefix(
+            uppercase_prefix(
                 Span::new(raw_span.start + 1, raw_span.start + 2),
                 if number_literal.starts_with("0B") { "0b" } else { "0o" },
             ),
@@ -103,27 +104,19 @@ fn check_number_literal(
         let has_lowercase_digits = number_literal[2..].chars().any(|c| ('a'..='f').contains(&c));
         if has_uppercase_prefix && has_lowercase_digits {
             return Some((
-                NumberLiteralCaseDiagnostic::UppercasePrefixAndLowercaseHexadecimalDigits(
-                    raw_span, "0x",
-                ),
+                uppercase_prefix_and_lowercase_hexadecimal_digits(raw_span, "0x"),
                 "0x".to_owned() + &digits_to_uppercase(&number_literal[2..]),
             ));
         }
         if has_uppercase_prefix {
             return Some((
-                NumberLiteralCaseDiagnostic::UppercasePrefix(
-                    Span::new(raw_span.start + 1, raw_span.start + 2),
-                    "0x",
-                ),
+                uppercase_prefix(Span::new(raw_span.start + 1, raw_span.start + 2), "0x"),
                 "0x".to_owned() + &number_literal[2..],
             ));
         }
         if has_lowercase_digits {
             return Some((
-                NumberLiteralCaseDiagnostic::LowercaseHexadecimalDigits(Span::new(
-                    raw_span.start + 2,
-                    raw_span.end,
-                )),
+                lowercase_hexadecimal_digits(Span::new(raw_span.start + 2, raw_span.end)),
                 "0x".to_owned() + &digits_to_uppercase(&number_literal[2..]),
             ));
         }
@@ -132,10 +125,7 @@ fn check_number_literal(
     if let Some(index) = number_literal.find('E') {
         let char_position = raw_span.start + index as u32;
         return Some((
-            NumberLiteralCaseDiagnostic::UppercaseExponentialNotation(Span::new(
-                char_position,
-                char_position + 1,
-            )),
+            uppercase_exponential_notation(Span::new(char_position, char_position + 1)),
             number_literal.to_lowercase(),
         ));
     }
diff --git a/crates/oxc_linter/src/rules/unicorn/numeric_separators_style.rs b/crates/oxc_linter/src/rules/unicorn/numeric_separators_style.rs
index 6eba1cc5b8de..744f54e5a0e9 100644
--- a/crates/oxc_linter/src/rules/unicorn/numeric_separators_style.rs
+++ b/crates/oxc_linter/src/rules/unicorn/numeric_separators_style.rs
@@ -3,23 +3,21 @@ use oxc_ast::{
     ast::{BigIntLiteral, NumericLiteral},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use regex::Regex;
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(numeric-separators-style): Invalid group length in numeric value.")]
-#[diagnostic(
-    severity(warning),
-    help("Group digits with numeric separators (_) so longer numbers are easier to read.")
-)]
-struct NumericSeparatorsStyleDiagnostic(#[label] pub Span);
+fn numeric_separators_style_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(numeric-separators-style): Invalid group length in numeric value.",
+    )
+    .with_help("Group digits with numeric separators (_) so longer numbers are easier to read.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct NumericSeparatorsStyle(Box<NumericSeparatorsStyleConfig>);
@@ -98,9 +96,10 @@ impl Rule for NumericSeparatorsStyle {
                 let formatted = self.format_number(number);
 
                 if formatted != number.raw {
-                    ctx.diagnostic_with_fix(NumericSeparatorsStyleDiagnostic(number.span), || {
-                        Fix::new(formatted, number.span)
-                    });
+                    ctx.diagnostic_with_fix(
+                        numeric_separators_style_diagnostic(number.span),
+                        || Fix::new(formatted, number.span),
+                    );
                 }
             }
             AstKind::BigintLiteral(number) => {
@@ -113,9 +112,10 @@ impl Rule for NumericSeparatorsStyle {
                 let formatted = self.format_bigint(number, raw);
 
                 if formatted.len() != number.span.size() as usize {
-                    ctx.diagnostic_with_fix(NumericSeparatorsStyleDiagnostic(number.span), || {
-                        Fix::new(formatted, number.span)
-                    });
+                    ctx.diagnostic_with_fix(
+                        numeric_separators_style_diagnostic(number.span),
+                        || Fix::new(formatted, number.span),
+                    );
                 }
             }
             _ => {}
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_add_event_listener.rs b/crates/oxc_linter/src/rules/unicorn/prefer_add_event_listener.rs
index c834bd4cca1a..79278662f6d8 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_add_event_listener.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_add_event_listener.rs
@@ -1,17 +1,14 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-add-event-listener): Prefer `addEventListener()` over their `on`-function counterparts.")]
-#[diagnostic(severity(warning))]
-struct PreferAddEventListenerDiagnostic(#[label] pub Span);
+fn prefer_add_event_listener_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-add-event-listener): Prefer `addEventListener()` over their `on`-function counterparts.").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferAddEventListener;
@@ -41,7 +38,9 @@ declare_oxc_lint!(
 
 impl Rule for PreferAddEventListener {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::AssignmentExpression(assignment_expr) = node.kind() else { return };
+        let AstKind::AssignmentExpression(assignment_expr) = node.kind() else {
+            return;
+        };
 
         let Some(member_expr) = assignment_expr.left.as_member_expression() else {
             return;
@@ -51,7 +50,9 @@ impl Rule for PreferAddEventListener {
             return;
         }
 
-        let Some((span, name)) = member_expr.static_property_info() else { return };
+        let Some((span, name)) = member_expr.static_property_info() else {
+            return;
+        };
 
         if !name.starts_with("on") {
             return;
@@ -61,7 +62,7 @@ impl Rule for PreferAddEventListener {
             return;
         }
 
-        ctx.diagnostic(PreferAddEventListenerDiagnostic(span));
+        ctx.diagnostic(prefer_add_event_listener_diagnostic(span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_array_flat.rs b/crates/oxc_linter/src/rules/unicorn/prefer_array_flat.rs
index 1ee370df8388..6e4464822bd3 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_array_flat.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_array_flat.rs
@@ -4,10 +4,8 @@ use oxc_ast::{
     },
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -20,10 +18,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-array-flat): Prefer Array#flat() over legacy techniques to flatten arrays.")]
-#[diagnostic(severity(warning), help(r"Call `.flat()` on the array instead."))]
-struct PreferArrayFlatDiagnostic(#[label] pub Span);
+fn prefer_array_flat_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-array-flat): Prefer Array#flat() over legacy techniques to flatten arrays.")
+        .with_help(r"Call `.flat()` on the array instead.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferArrayFlat;
@@ -99,7 +98,7 @@ fn check_array_flat_map_case<'a>(call_expr: &CallExpression<'a>, ctx: &LintConte
         return;
     }
 
-    ctx.diagnostic(PreferArrayFlatDiagnostic(call_expr.span));
+    ctx.diagnostic(prefer_array_flat_diagnostic(call_expr.span));
 }
 
 // `array.reduce((a, b) => a.concat(b), [])`
@@ -161,7 +160,7 @@ fn check_array_reduce_case<'a>(call_expr: &CallExpression<'a>, ctx: &LintContext
                     return;
                 }
 
-                ctx.diagnostic(PreferArrayFlatDiagnostic(call_expr.span));
+                ctx.diagnostic(prefer_array_flat_diagnostic(call_expr.span));
             }
         }
     }
@@ -193,7 +192,7 @@ fn check_array_reduce_case<'a>(call_expr: &CallExpression<'a>, ctx: &LintContext
             return;
         }
 
-        ctx.diagnostic(PreferArrayFlatDiagnostic(call_expr.span));
+        ctx.diagnostic(prefer_array_flat_diagnostic(call_expr.span));
     };
 }
 
@@ -208,7 +207,7 @@ fn check_array_concat_case<'a>(call_expr: &CallExpression<'a>, ctx: &LintContext
             if !array_expr.elements.is_empty() {
                 return;
             }
-            ctx.diagnostic(PreferArrayFlatDiagnostic(call_expr.span));
+            ctx.diagnostic(prefer_array_flat_diagnostic(call_expr.span));
         }
     }
 }
@@ -232,7 +231,7 @@ fn check_array_prototype_concat_case<'a>(call_expr: &CallExpression<'a>, ctx: &L
                     && (is_call_call
                         || !matches!(call_expr.arguments.get(1), Some(Argument::SpreadElement(_))))
                 {
-                    ctx.diagnostic(PreferArrayFlatDiagnostic(call_expr.span));
+                    ctx.diagnostic(prefer_array_flat_diagnostic(call_expr.span));
                 }
             }
         }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_array_flat_map.rs b/crates/oxc_linter/src/rules/unicorn/prefer_array_flat_map.rs
index c5afa1529505..6e4649976ee1 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_array_flat_map.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_array_flat_map.rs
@@ -2,19 +2,18 @@ use oxc_ast::{
     ast::{Argument, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{ast_util::is_method_call, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-array-flat-map): `Array.flatMap` performs `Array.map` and `Array.flat` in one step.")]
-#[diagnostic(severity(warning), help("Prefer `.flatMap(…)` over `.map(…).flat()`."))]
-struct PreferArrayFlatMapDiagnostic(#[label] pub Span);
+fn prefer_array_flat_map_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-array-flat-map): `Array.flatMap` performs `Array.map` and `Array.flat` in one step.")
+        .with_help("Prefer `.flatMap(…)` over `.map(…).flat()`.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferArrayFlatMap;
@@ -40,7 +39,9 @@ declare_oxc_lint!(
 
 impl Rule for PreferArrayFlatMap {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(flat_call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(flat_call_expr) = node.kind() else {
+            return;
+        };
 
         if flat_call_expr.arguments.len() > 1 {
             return;
@@ -49,7 +50,9 @@ impl Rule for PreferArrayFlatMap {
         if !is_method_call(flat_call_expr, None, Some(&["flat"]), None, None) {
             return;
         }
-        let Some(member_expr) = flat_call_expr.callee.as_member_expression() else { return };
+        let Some(member_expr) = flat_call_expr.callee.as_member_expression() else {
+            return;
+        };
         let Expression::CallExpression(call_expr) = &member_expr.object().without_parenthesized()
         else {
             return;
@@ -68,7 +71,7 @@ impl Rule for PreferArrayFlatMap {
             }
         }
 
-        ctx.diagnostic(PreferArrayFlatMapDiagnostic(flat_call_expr.span));
+        ctx.diagnostic(prefer_array_flat_map_diagnostic(flat_call_expr.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_array_some.rs b/crates/oxc_linter/src/rules/unicorn/prefer_array_some.rs
index 96226ad7ccb7..da7348fc7b7f 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_array_some.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_array_some.rs
@@ -9,22 +9,17 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::BinaryOperator;
 
-#[derive(Debug, Error, Diagnostic)]
-enum PreferArraySomeDiagnostic {
-    #[error("eslint-plugin-unicorn(prefer-array-some): Prefer `.some(…)` over `.find(…)`or `.findLast(…)`.")]
-    #[diagnostic(severity(warning))]
-    OverMethod(#[label] Span),
-    #[error("eslint-plugin-unicorn(prefer-array-some): Prefer `.some(…)` over non-zero length check from `.filter(…)`.")]
-    #[diagnostic(severity(warning))]
-    NonZeroFilter(#[label] Span),
+fn over_method(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-array-some): Prefer `.some(…)` over `.find(…)`or `.findLast(…)`.").with_labels([span0.into()])
+}
+
+fn non_zero_filter(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-array-some): Prefer `.some(…)` over non-zero length check from `.filter(…)`.").with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -64,7 +59,7 @@ impl Rule for PreferArraySome {
                     return;
                 }
 
-                ctx.diagnostic(PreferArraySomeDiagnostic::OverMethod(
+                ctx.diagnostic(over_method(
                     // SAFETY: `call_expr_method_callee_info` returns `Some` if `is_method_call` returns `true`.
                     call_expr_method_callee_info(call_expr).unwrap().0,
                 ));
@@ -77,7 +72,9 @@ impl Rule for PreferArraySome {
                     return;
                 }
 
-                let Expression::NumericLiteral(right_num_lit) = &bin_expr.right else { return };
+                let Expression::NumericLiteral(right_num_lit) = &bin_expr.right else {
+                    return;
+                };
 
                 if right_num_lit.raw != "0" {
                     return;
@@ -117,7 +114,7 @@ impl Rule for PreferArraySome {
                     return;
                 }
 
-                ctx.diagnostic(PreferArraySomeDiagnostic::NonZeroFilter(
+                ctx.diagnostic(non_zero_filter(
                     // SAFETY: `call_expr_method_callee_info` returns `Some` if `is_method_call` returns `true`.
                     call_expr_method_callee_info(left_call_expr).unwrap().0,
                 ));
@@ -166,9 +163,13 @@ fn is_checking_undefined<'a, 'b>(
     _call_expr: &'b CallExpression<'a>,
     ctx: &'b LintContext<'a>,
 ) -> bool {
-    let Some(parent) = outermost_paren_parent(node, ctx) else { return false };
+    let Some(parent) = outermost_paren_parent(node, ctx) else {
+        return false;
+    };
 
-    let AstKind::BinaryExpression(bin_expr) = parent.kind() else { return false };
+    let AstKind::BinaryExpression(bin_expr) = parent.kind() else {
+        return false;
+    };
 
     let right_without_paren = bin_expr.right.without_parenthesized();
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_blob_reading_methods.rs b/crates/oxc_linter/src/rules/unicorn/prefer_blob_reading_methods.rs
index 88bf37c286e0..099545d0fe1b 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_blob_reading_methods.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_blob_reading_methods.rs
@@ -1,17 +1,14 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-blob-reading-methods): Prefer `Blob#{1}()` over `FileReader#{2}(blob)`.")]
-#[diagnostic(severity(warning))]
-struct PreferBlobReadingMethodsDiagnostic(#[label] pub Span, pub &'static str, pub &'static str);
+fn prefer_blob_reading_methods_diagnostic(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(prefer-blob-reading-methods): Prefer `Blob#{x1}()` over `FileReader#{x2}(blob)`.")).with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferBlobReadingMethods;
@@ -48,9 +45,13 @@ declare_oxc_lint!(
 
 impl Rule for PreferBlobReadingMethods {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
-        let Some(member_expr) = call_expr.callee.as_member_expression() else { return };
+        let Some(member_expr) = call_expr.callee.as_member_expression() else {
+            return;
+        };
 
         if member_expr.is_computed()
             || member_expr.optional()
@@ -66,7 +67,7 @@ impl Rule for PreferBlobReadingMethods {
             _ => return,
         };
 
-        ctx.diagnostic(PreferBlobReadingMethodsDiagnostic(span, replacement, current));
+        ctx.diagnostic(prefer_blob_reading_methods_diagnostic(span, replacement, current));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_code_point.rs b/crates/oxc_linter/src/rules/unicorn/prefer_code_point.rs
index 2d5d47821a36..0415ce5242c3 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_code_point.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_code_point.rs
@@ -1,17 +1,18 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-code-point): Prefer `{1}` over `{2}`")]
-#[diagnostic(severity(warning), help("Unicode is better supported in `{1}` than `{2}`"))]
-struct PreferCodePointDiagnostic(#[label] pub Span, pub &'static str, pub &'static str);
+fn prefer_code_point_diagnostic(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(prefer-code-point): Prefer `{x1}` over `{x2}`"
+    ))
+    .with_help(format!("Unicode is better supported in `{x1}` than `{x2}`"))
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferCodePoint;
@@ -44,9 +45,13 @@ declare_oxc_lint!(
 
 impl Rule for PreferCodePoint {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
-        let Some(memb_expr) = call_expr.callee.as_member_expression() else { return };
+        let Some(memb_expr) = call_expr.callee.as_member_expression() else {
+            return;
+        };
 
         if memb_expr.is_computed() || memb_expr.optional() || call_expr.optional {
             return;
@@ -58,7 +63,7 @@ impl Rule for PreferCodePoint {
             _ => return,
         };
 
-        ctx.diagnostic(PreferCodePointDiagnostic(span, replacement, current));
+        ctx.diagnostic(prefer_code_point_diagnostic(span, replacement, current));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_date_now.rs b/crates/oxc_linter/src/rules/unicorn/prefer_date_now.rs
index 017fb2b8a74b..cbd7e89126ea 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_date_now.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_date_now.rs
@@ -2,32 +2,35 @@ use oxc_ast::{
     ast::{Argument, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, GetSpan, Span};
+use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, UnaryOperator};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[allow(clippy::enum_variant_names)]
-enum PreferDateNowDiagnostic {
-    #[error("eslint-plugin-unicorn(prefer-date-now): Prefer `Date.now()` over `new Date()`")]
-    #[diagnostic(severity(warning), help("Change to `Date.now()`."))]
-    PreferDateNow(#[label] Span),
-
-    #[error("eslint-plugin-unicorn(prefer-date-now): Prefer `Date.now()` over `new Date().{1}()`")]
-    #[diagnostic(severity(warning), help("Change to `Date.now()`."))]
-    PreferDateNowOverMethods(#[label] Span, CompactStr),
-
-    #[error(
-        "eslint-plugin-unicorn(prefer-date-now): Prefer `Date.now()` over `Number(new Date())`"
-    )]
-    #[diagnostic(severity(warning), help("Change to `Date.now()`."))]
-    PreferDateNowOverNumberDateObject(#[label] Span),
+fn prefer_date_now(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(prefer-date-now): Prefer `Date.now()` over `new Date()`",
+    )
+    .with_help("Change to `Date.now()`.")
+    .with_labels([span0.into()])
+}
+
+fn prefer_date_now_over_methods(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(prefer-date-now): Prefer `Date.now()` over `new Date().{x1}()`"
+    ))
+    .with_help("Change to `Date.now()`.")
+    .with_labels([span0.into()])
+}
+
+fn prefer_date_now_over_number_date_object(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(prefer-date-now): Prefer `Date.now()` over `Number(new Date())`",
+    )
+    .with_help("Change to `Date.now()`.")
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -69,9 +72,9 @@ impl Rule for PreferDateNow {
                         && matches!(member_expr.static_property_name(), Some("getTime" | "valueOf"))
                         && is_new_date(member_expr.object().without_parenthesized())
                     {
-                        ctx.diagnostic(PreferDateNowDiagnostic::PreferDateNowOverMethods(
+                        ctx.diagnostic(prefer_date_now_over_methods(
                             call_expr.span,
-                            member_expr.static_property_name().unwrap().into(),
+                            member_expr.static_property_name().unwrap(),
                         ));
                     }
                 }
@@ -85,11 +88,9 @@ impl Rule for PreferDateNow {
                             call_expr.arguments.first().and_then(Argument::as_expression)
                         {
                             if is_new_date(expr.without_parenthesized()) {
-                                ctx.diagnostic(
-                                    PreferDateNowDiagnostic::PreferDateNowOverNumberDateObject(
-                                        call_expr.span,
-                                    ),
-                                );
+                                ctx.diagnostic(prefer_date_now_over_number_date_object(
+                                    call_expr.span,
+                                ));
                             }
                         }
                     }
@@ -103,9 +104,7 @@ impl Rule for PreferDateNow {
                     return;
                 }
                 if is_new_date(&unary_expr.argument) {
-                    ctx.diagnostic(PreferDateNowDiagnostic::PreferDateNow(
-                        unary_expr.argument.span(),
-                    ));
+                    ctx.diagnostic(prefer_date_now(unary_expr.argument.span()));
                 }
             }
             AstKind::AssignmentExpression(assignment_expr) => {
@@ -121,9 +120,7 @@ impl Rule for PreferDateNow {
                 }
 
                 if is_new_date(&assignment_expr.right) {
-                    ctx.diagnostic(PreferDateNowDiagnostic::PreferDateNow(
-                        assignment_expr.right.span(),
-                    ));
+                    ctx.diagnostic(prefer_date_now(assignment_expr.right.span()));
                 }
             }
             AstKind::BinaryExpression(bin_expr) => {
@@ -139,10 +136,10 @@ impl Rule for PreferDateNow {
                 }
 
                 if is_new_date(&bin_expr.left) {
-                    ctx.diagnostic(PreferDateNowDiagnostic::PreferDateNow(bin_expr.left.span()));
+                    ctx.diagnostic(prefer_date_now(bin_expr.left.span()));
                 }
                 if is_new_date(&bin_expr.right) {
-                    ctx.diagnostic(PreferDateNowDiagnostic::PreferDateNow(bin_expr.right.span()));
+                    ctx.diagnostic(prefer_date_now(bin_expr.right.span()));
                 }
             }
             _ => {}
@@ -151,7 +148,9 @@ impl Rule for PreferDateNow {
 }
 
 fn is_new_date(expr: &Expression) -> bool {
-    let Expression::NewExpression(new_expr) = expr.without_parenthesized() else { return false };
+    let Expression::NewExpression(new_expr) = expr.without_parenthesized() else {
+        return false;
+    };
 
     if let Expression::Identifier(ident) = &new_expr.callee {
         return ident.name == "Date" && new_expr.arguments.is_empty();
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_append.rs b/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_append.rs
index c3306bc87d0f..297f326cf7ac 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_append.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_append.rs
@@ -1,8 +1,6 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -10,10 +8,11 @@ use oxc_ast::ast::MemberExpression;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-dom-node-append): Prefer `Node#append()` over `Node#appendChild()` for DOM nodes.")]
-#[diagnostic(severity(warning), help("Replace `Node#appendChild()` with `Node#append()`."))]
-struct PreferDomNodeAppendDiagnostic(#[label] pub Span);
+fn prefer_dom_node_append_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-dom-node-append): Prefer `Node#append()` over `Node#appendChild()` for DOM nodes.")
+        .with_help("Replace `Node#appendChild()` with `Node#append()`.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferDomNodeAppend;
@@ -50,7 +49,9 @@ impl Rule for PreferDomNodeAppend {
             return;
         }
 
-        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
 
         let span = match member_expr {
             MemberExpression::StaticMemberExpression(v) => {
@@ -70,7 +71,7 @@ impl Rule for PreferDomNodeAppend {
             return;
         }
 
-        ctx.diagnostic(PreferDomNodeAppendDiagnostic(span));
+        ctx.diagnostic(prefer_dom_node_append_diagnostic(span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_dataset.rs b/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_dataset.rs
index 25a19fe303a0..71c0d5037ac7 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_dataset.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_dataset.rs
@@ -1,39 +1,32 @@
 use oxc_ast::{ast::Argument, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum PreferDomNodeDatasetDiagnostic {
-    #[error("eslint-plugin-unicorn(prefer-dom-node-dataset): Prefer using `dataset` over `setAttribute`.")]
-    #[diagnostic(
-        severity(warning),
-        help("Access the `.dataset` object directly: `element.dataset.{1} = ...;`")
-    )]
-    Set(#[label] Span, String),
-    #[error("eslint-plugin-unicorn(prefer-dom-node-dataset): Prefer using `dataset` over `getAttribute`.")]
-    #[diagnostic(
-        severity(warning),
-        help("Access the `.dataset` object directly: `element.dataset.{1}`")
-    )]
-    Get(#[label] Span, String),
-    #[error("eslint-plugin-unicorn(prefer-dom-node-dataset): Prefer using `dataset` over `hasAttribute`.")]
-    #[diagnostic(
-        severity(warning),
-        help("Check the `dataset` object directly: `Object.hasOwn(element.dataset, '{1}')")
-    )]
-    Has(#[label] Span, String),
-    #[error("eslint-plugin-unicorn(prefer-dom-node-dataset): Prefer using `dataset` over `removeAttribute`.")]
-    #[diagnostic(
-        severity(warning),
-        help("Access the `.dataset` object directly: `delete element.dataset.{1};")
-    )]
-    Remove(#[label] Span, String),
+fn set(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-dom-node-dataset): Prefer using `dataset` over `setAttribute`.")
+        .with_help(format!("Access the `.dataset` object directly: `element.dataset.{x1} = ...;`"))
+        .with_labels([span0.into()])
+}
+
+fn get(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-dom-node-dataset): Prefer using `dataset` over `getAttribute`.")
+        .with_help(format!("Access the `.dataset` object directly: `element.dataset.{x1}`"))
+        .with_labels([span0.into()])
+}
+
+fn has(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-dom-node-dataset): Prefer using `dataset` over `hasAttribute`.")
+        .with_help(format!("Check the `dataset` object directly: `Object.hasOwn(element.dataset, '{x1}')"))
+        .with_labels([span0.into()])
+}
+
+fn remove(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-dom-node-dataset): Prefer using `dataset` over `removeAttribute`.")
+        .with_help(format!("Access the `.dataset` object directly: `delete element.dataset.{x1};"))
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -66,13 +59,17 @@ impl Rule for PreferDomNodeDataset {
             return;
         };
 
-        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
 
         if member_expr.is_computed() {
             return;
         }
 
-        let Some((span, method_name)) = member_expr.static_property_info() else { return };
+        let Some((span, method_name)) = member_expr.static_property_info() else {
+            return;
+        };
 
         match method_name {
             "setAttribute" => {
@@ -98,19 +95,16 @@ impl Rule for PreferDomNodeDataset {
 
         match method_name {
             "setAttribute" => {
-                ctx.diagnostic(PreferDomNodeDatasetDiagnostic::Set(span, dataset_property_name));
+                ctx.diagnostic(set(span, &dataset_property_name));
             }
             "getAttribute" => {
-                ctx.diagnostic(PreferDomNodeDatasetDiagnostic::Get(span, dataset_property_name));
+                ctx.diagnostic(get(span, &dataset_property_name));
             }
 
-            "removeAttribute" => ctx.diagnostic(PreferDomNodeDatasetDiagnostic::Remove(
-                string_lit.span,
-                dataset_property_name,
-            )),
+            "removeAttribute" => ctx.diagnostic(remove(string_lit.span, &dataset_property_name)),
 
             "hasAttribute" => {
-                ctx.diagnostic(PreferDomNodeDatasetDiagnostic::Has(span, dataset_property_name));
+                ctx.diagnostic(has(span, &dataset_property_name));
             }
 
             _ => unreachable!(),
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_remove.rs b/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_remove.rs
index b9c6a2d2f394..951ab24b970a 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_remove.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_remove.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
@@ -13,15 +11,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-dom-node-remove): Prefer `childNode.remove()` over `parentNode.removeChild(childNode)`.")]
-#[diagnostic(
-    severity(warning),
-    help(
-        "Replace `parentNode.removeChild(childNode)` with `childNode{{dotOrQuestionDot}}remove()`."
-    )
-)]
-struct PreferDomNodeRemoveDiagnostic(#[label] pub Span);
+fn prefer_dom_node_remove_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-dom-node-remove): Prefer `childNode.remove()` over `parentNode.removeChild(childNode)`.")
+        .with_help("Replace `parentNode.removeChild(childNode)` with `childNode{dotOrQuestionDot}remove()`.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferDomNodeRemove;
@@ -49,7 +43,9 @@ declare_oxc_lint!(
 
 impl Rule for PreferDomNodeRemove {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
         if call_expr.optional {
             return;
@@ -78,7 +74,7 @@ impl Rule for PreferDomNodeRemove {
             return;
         }
 
-        ctx.diagnostic(PreferDomNodeRemoveDiagnostic(
+        ctx.diagnostic(prefer_dom_node_remove_diagnostic(
             call_expr_method_callee_info(call_expr).unwrap().0,
         ));
     }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_text_content.rs b/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_text_content.rs
index 247e40bed869..623b3be8d5d4 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_text_content.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_dom_node_text_content.rs
@@ -1,19 +1,16 @@
 use oxc_ast::AstKind;
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-unicorn(prefer-dom-node-text-content): Prefer `.textContent` over `.innerText`."
-)]
-#[diagnostic(severity(warning), help("Replace `.innerText` with `.textContent`."))]
-struct PreferDomNodeTextContentDiagnostic(#[label] pub Span);
+fn prefer_dom_node_text_content_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-dom-node-text-content): Prefer `.textContent` over `.innerText`.")
+        .with_help("Replace `.innerText` with `.textContent`.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferDomNodeTextContent;
@@ -47,7 +44,7 @@ impl Rule for PreferDomNodeTextContent {
         if let AstKind::MemberExpression(member_expr) = node.kind() {
             if let Some((span, name)) = member_expr.static_property_info() {
                 if name == "innerText" && !member_expr.is_computed() {
-                    ctx.diagnostic_with_fix(PreferDomNodeTextContentDiagnostic(span), || {
+                    ctx.diagnostic_with_fix(prefer_dom_node_text_content_diagnostic(span), || {
                         Fix::new("textContent", span)
                     });
                 }
@@ -72,7 +69,7 @@ impl Rule for PreferDomNodeTextContent {
                 && (matches!(grand_parent_node_kind, AstKind::ObjectPattern(_))
                     || matches!(grand_parent_node_kind, AstKind::AssignmentTarget(_)))
             {
-                ctx.diagnostic(PreferDomNodeTextContentDiagnostic(identifier.span));
+                ctx.diagnostic(prefer_dom_node_text_content_diagnostic(identifier.span));
                 return;
             }
         }
@@ -83,7 +80,7 @@ impl Rule for PreferDomNodeTextContent {
                 && matches!(parent_node_kind, AstKind::AssignmentTarget(_))
                 && matches!(grand_parent_node_kind, AstKind::AssignmentExpression(_))
             {
-                ctx.diagnostic(PreferDomNodeTextContentDiagnostic(identifier_ref.span));
+                ctx.diagnostic(prefer_dom_node_text_content_diagnostic(identifier_ref.span));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_event_target.rs b/crates/oxc_linter/src/rules/unicorn/prefer_event_target.rs
index f0ae9ad26d2a..7396a5ad2fd3 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_event_target.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_event_target.rs
@@ -1,17 +1,16 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-event-target): Prefer `EventTarget` over `EventEmitter`")]
-#[diagnostic(severity(warning), help("Change `EventEmitter` to `EventTarget`. EventEmitters are only available in Node.js, while EventTargets are also available in browsers."))]
-struct PreferEventTargetDiagnostic(#[label] pub Span);
+fn prefer_event_target_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-event-target): Prefer `EventTarget` over `EventEmitter`")
+        .with_help("Change `EventEmitter` to `EventTarget`. EventEmitters are only available in Node.js, while EventTargets are also available in browsers.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferEventTarget;
@@ -43,7 +42,9 @@ declare_oxc_lint!(
 
 impl Rule for PreferEventTarget {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::IdentifierReference(ident) = node.kind() else { return };
+        let AstKind::IdentifierReference(ident) = node.kind() else {
+            return;
+        };
 
         if ident.name.as_str() != "EventEmitter" {
             return;
@@ -67,7 +68,7 @@ impl Rule for PreferEventTarget {
             _ => return,
         };
 
-        ctx.diagnostic(PreferEventTargetDiagnostic(ident.span));
+        ctx.diagnostic(prefer_event_target_diagnostic(ident.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_includes.rs b/crates/oxc_linter/src/rules/unicorn/prefer_includes.rs
index cbd9e85a8b28..c929869f38a0 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_includes.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_includes.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::{BinaryOperator, UnaryOperator};
@@ -14,10 +12,9 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-includes): Prefer `includes()` over `indexOf()` when checking for existence or non-existence.")]
-#[diagnostic(severity(warning))]
-struct PreferIncludesDiagnostic(#[label] pub Span);
+fn prefer_includes_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-includes): Prefer `includes()` over `indexOf()` when checking for existence or non-existence.").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferIncludes;
@@ -72,7 +69,7 @@ impl Rule for PreferIncludes {
                 return;
             }
 
-            ctx.diagnostic(PreferIncludesDiagnostic(
+            ctx.diagnostic(prefer_includes_diagnostic(
                 call_expr_method_callee_info(left_call_expr).unwrap().0,
             ));
         }
@@ -86,7 +83,7 @@ impl Rule for PreferIncludes {
             if num_lit.raw != "0" {
                 return;
             }
-            ctx.diagnostic(PreferIncludesDiagnostic(
+            ctx.diagnostic(prefer_includes_diagnostic(
                 call_expr_method_callee_info(left_call_expr).unwrap().0,
             ));
         }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_logical_operator_over_ternary.rs b/crates/oxc_linter/src/rules/unicorn/prefer_logical_operator_over_ternary.rs
index 7539d7bed2bb..56f765e8684d 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_logical_operator_over_ternary.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_logical_operator_over_ternary.rs
@@ -1,18 +1,17 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::UnaryOperator;
 
 use crate::{context::LintContext, rule::Rule, utils::is_same_reference, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-logical-operator-over-ternary): Prefer using a logical operator over a ternary.")]
-#[diagnostic(severity(warning), help("Switch to \"||\" or \"??\" operator"))]
-struct PreferLogicalOperatorOverTernaryDiagnostic(#[label] pub Span);
+fn prefer_logical_operator_over_ternary_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-logical-operator-over-ternary): Prefer using a logical operator over a ternary.")
+        .with_help("Switch to \"||\" or \"??\" operator")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferLogicalOperatorOverTernary;
@@ -44,10 +43,14 @@ declare_oxc_lint!(
 
 impl Rule for PreferLogicalOperatorOverTernary {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::ConditionalExpression(conditional_expression) = node.kind() else { return };
+        let AstKind::ConditionalExpression(conditional_expression) = node.kind() else {
+            return;
+        };
 
         if is_same_node(&conditional_expression.test, &conditional_expression.consequent, ctx) {
-            ctx.diagnostic(PreferLogicalOperatorOverTernaryDiagnostic(conditional_expression.span));
+            ctx.diagnostic(prefer_logical_operator_over_ternary_diagnostic(
+                conditional_expression.span,
+            ));
         }
 
         // `!bar ? foo : bar;`
@@ -55,7 +58,7 @@ impl Rule for PreferLogicalOperatorOverTernary {
             if unary_expression.operator == UnaryOperator::LogicalNot
                 && is_same_node(&unary_expression.argument, &conditional_expression.alternate, ctx)
             {
-                ctx.diagnostic(PreferLogicalOperatorOverTernaryDiagnostic(
+                ctx.diagnostic(prefer_logical_operator_over_ternary_diagnostic(
                     conditional_expression.span,
                 ));
             }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_math_trunc.rs b/crates/oxc_linter/src/rules/unicorn/prefer_math_trunc.rs
index f8b0cdcd2277..6d11982bb5cb 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_math_trunc.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_math_trunc.rs
@@ -1,18 +1,18 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, UnaryOperator};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-math-trunc): Prefer `Math.trunc()` over instead of `{1} 0`.")]
-#[diagnostic(severity(warning))]
-struct PreferMathTruncDiagnostic(#[label] pub Span, pub &'static str);
+fn prefer_math_trunc_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(prefer-math-trunc): Prefer `Math.trunc()` over instead of `{x1} 0`."
+    ))
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferMathTrunc;
@@ -116,7 +116,7 @@ impl Rule for PreferMathTrunc {
             }
         };
 
-        ctx.diagnostic(PreferMathTruncDiagnostic(node.kind().span(), operator));
+        ctx.diagnostic(prefer_math_trunc_diagnostic(node.kind().span(), operator));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_modern_dom_apis.rs b/crates/oxc_linter/src/rules/unicorn/prefer_modern_dom_apis.rs
index 6ee6520bbe0e..5d23f097efe4 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_modern_dom_apis.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_modern_dom_apis.rs
@@ -2,20 +2,20 @@ use oxc_ast::{
     ast::{Argument, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 use phf::phf_map;
 
 use crate::{ast_util::is_method_call, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-modern-dom-apis): Prefer using `{0}` over `{1}`.")]
-#[diagnostic(severity(warning))]
-struct PreferModernDomApisDiagnostic(pub &'static str, CompactStr, #[label] pub Span);
+fn prefer_modern_dom_apis_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(prefer-modern-dom-apis): Prefer using `{x0}` over `{x1}`."
+    ))
+    .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferModernDomApis;
@@ -85,9 +85,9 @@ impl Rule for PreferModernDomApis {
             && !call_expr.optional
         {
             if let Some(preferred_method) = DISALLOWED_METHODS.get(method) {
-                ctx.diagnostic(PreferModernDomApisDiagnostic(
+                ctx.diagnostic(prefer_modern_dom_apis_diagnostic(
                     preferred_method,
-                    CompactStr::from(method),
+                    method,
                     member_expr.property.span,
                 ));
 
@@ -105,9 +105,9 @@ impl Rule for PreferModernDomApis {
             if let Argument::StringLiteral(lit) = &call_expr.arguments[0] {
                 for (position, replacer) in &POSITION_REPLACERS {
                     if lit.value == position {
-                        ctx.diagnostic(PreferModernDomApisDiagnostic(
+                        ctx.diagnostic(prefer_modern_dom_apis_diagnostic(
                             replacer,
-                            CompactStr::from(method),
+                            method,
                             member_expr.property.span,
                         ));
                     }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_modern_math_apis.rs b/crates/oxc_linter/src/rules/unicorn/prefer_modern_math_apis.rs
index 3e09af6e6b99..c3ca2f5bbbf1 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_modern_math_apis.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_modern_math_apis.rs
@@ -2,10 +2,7 @@ use oxc_ast::{
     ast::{Argument, BinaryExpression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use oxc_syntax::operator::BinaryOperator;
@@ -14,23 +11,25 @@ use crate::{
     ast_util::is_method_call, context::LintContext, rule::Rule, utils::is_same_reference, AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum PreferModernMathApisDiagnostic {
-    #[error(
-        "eslint-plugin-unicorn(prefer-modern-math-apis): Prefer `Math.abs(x)` over alternatives"
-    )]
-    #[diagnostic(severity(warning))]
-    PreferMathAbs(#[label] Span),
-
-    #[error(
-        "eslint-plugin-unicorn(prefer-modern-math-apis): Prefer `Math.hypot(…)` over alternatives"
-    )]
-    #[diagnostic(severity(warning))]
-    PreferMathHypot(#[label] Span),
-
-    #[error("eslint-plugin-unicorn(prefer-modern-math-apis): Prefer `Math.{1}(x)` over `{2}`")]
-    #[diagnostic(severity(warning))]
-    PreferMathLogN(#[label] Span, &'static str, String),
+fn prefer_math_abs(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(prefer-modern-math-apis): Prefer `Math.abs(x)` over alternatives",
+    )
+    .with_labels([span0.into()])
+}
+
+fn prefer_math_hypot(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(prefer-modern-math-apis): Prefer `Math.hypot(…)` over alternatives",
+    )
+    .with_labels([span0.into()])
+}
+
+fn prefer_math_log_n(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(prefer-modern-math-apis): Prefer `Math.{x1}(x)` over `{x2}`"
+    ))
+    .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -98,7 +97,9 @@ impl Rule for PreferModernMathApis {
                     return;
                 };
 
-                let Some(arg) = call_expr.arguments[0].as_expression() else { return };
+                let Some(arg) = call_expr.arguments[0].as_expression() else {
+                    return;
+                };
 
                 let expressions = flat_plus_expression(arg);
                 if expressions.iter().any(|expr| !is_pow_2_expression(expr, ctx)) {
@@ -106,9 +107,9 @@ impl Rule for PreferModernMathApis {
                 }
 
                 if expressions.len() == 1 {
-                    ctx.diagnostic(PreferModernMathApisDiagnostic::PreferMathAbs(call_expr.span));
+                    ctx.diagnostic(prefer_math_abs(call_expr.span));
                 } else {
-                    ctx.diagnostic(PreferModernMathApisDiagnostic::PreferMathHypot(call_expr.span));
+                    ctx.diagnostic(prefer_math_hypot(call_expr.span));
                 }
             }
             _ => {}
@@ -158,10 +159,10 @@ fn check_prefer_log<'a>(expr: &BinaryExpression<'a>, ctx: &LintContext<'a>) {
                 return;
             };
 
-            ctx.diagnostic(PreferModernMathApisDiagnostic::PreferMathLogN(
+            ctx.diagnostic(prefer_math_log_n(
                 expr.span,
                 get_math_log_replacement(member_expr.static_property_name()),
-                clean_string(expr.span.source_text(ctx.source_text())),
+                &clean_string(expr.span.source_text(ctx.source_text())),
             ));
         }
         _ => {}
@@ -214,10 +215,10 @@ fn check_multiplication<'a, 'b>(
         return;
     };
 
-    ctx.diagnostic(PreferModernMathApisDiagnostic::PreferMathLogN(
+    ctx.diagnostic(prefer_math_log_n(
         expr_span,
         get_math_log_replacement(member_expr.static_property_name()),
-        clean_string(expr_span.source_text(ctx.source_text())),
+        &clean_string(expr_span.source_text(ctx.source_text())),
     ));
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_native_coercion_functions.rs b/crates/oxc_linter/src/rules/unicorn/prefer_native_coercion_functions.rs
index 68026954c828..dcad304e1155 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_native_coercion_functions.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_native_coercion_functions.rs
@@ -2,24 +2,20 @@ use oxc_ast::{
     ast::{Argument, BindingPatternKind, Expression, FormalParameters, FunctionBody, Statement},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNodeId;
 use oxc_span::{Atom, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum PreferNativeCoercionFunctionsDiagnostic {
-    #[error("eslint-plugin-unicorn(prefer-native-coercion-functions): The function is equivalent to `{1}`. Call `{1}` directly.")]
-    #[diagnostic(severity(warning))]
-    Function(#[label] Span, &'static str),
-    #[error("eslint-plugin-unicorn(prefer-native-coercion-functions): The arrow function in the callback of the array is equivalent to `Boolean`. Replace the callback with `Boolean`.")]
-    #[diagnostic(severity(warning))]
-    ArrayCallback(#[label] Span),
+fn function(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(prefer-native-coercion-functions): The function is equivalent to `{x1}`. Call `{x1}` directly.")).with_labels([span0.into()])
+}
+
+fn array_callback(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-native-coercion-functions): The arrow function in the callback of the array is equivalent to `Boolean`. Replace the callback with `Boolean`.")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -63,10 +59,7 @@ impl Rule for PreferNativeCoercionFunctions {
                 if let Some(call_expr_ident) =
                     check_function(&arrow_expr.params, &arrow_expr.body, true)
                 {
-                    ctx.diagnostic(PreferNativeCoercionFunctionsDiagnostic::Function(
-                        arrow_expr.span,
-                        call_expr_ident,
-                    ));
+                    ctx.diagnostic(function(arrow_expr.span, call_expr_ident));
                 }
 
                 if check_array_callback_methods(
@@ -76,9 +69,7 @@ impl Rule for PreferNativeCoercionFunctions {
                     true,
                     ctx,
                 ) {
-                    ctx.diagnostic(PreferNativeCoercionFunctionsDiagnostic::ArrayCallback(
-                        arrow_expr.span,
-                    ));
+                    ctx.diagnostic(array_callback(arrow_expr.span));
                 }
             }
             AstKind::Function(func) => {
@@ -94,10 +85,7 @@ impl Rule for PreferNativeCoercionFunctions {
                     if let Some(call_expr_ident) =
                         check_function(&func.params, function_body, false)
                     {
-                        ctx.diagnostic(PreferNativeCoercionFunctionsDiagnostic::Function(
-                            func.span,
-                            call_expr_ident,
-                        ));
+                        ctx.diagnostic(function(func.span, call_expr_ident));
                     }
                 }
             }
@@ -174,13 +162,17 @@ fn is_matching_native_coercion_function_call(
     expr: &Expression,
     first_arg_name: &str,
 ) -> Option<&'static str> {
-    let Expression::CallExpression(call_expr) = expr else { return None };
+    let Expression::CallExpression(call_expr) = expr else {
+        return None;
+    };
 
     if call_expr.optional || call_expr.arguments.len() == 0 {
         return None;
     }
 
-    let Expression::Identifier(callee_ident) = &call_expr.callee else { return None };
+    let Expression::Identifier(callee_ident) = &call_expr.callee else {
+        return None;
+    };
 
     let fn_name = NATIVE_COERCION_FUNCTION_NAMES.get_key(callee_ident.name.as_str())?;
 
@@ -201,10 +193,18 @@ fn check_array_callback_methods(
     is_arrow: bool,
     ctx: &LintContext,
 ) -> bool {
-    let Some(parent) = ctx.nodes().parent_node(node_id) else { return false };
-    let AstKind::Argument(parent_call_expr_arg) = parent.kind() else { return false };
-    let Some(grand_parent) = ctx.nodes().parent_node(parent.id()) else { return false };
-    let AstKind::CallExpression(call_expr) = grand_parent.kind() else { return false };
+    let Some(parent) = ctx.nodes().parent_node(node_id) else {
+        return false;
+    };
+    let AstKind::Argument(parent_call_expr_arg) = parent.kind() else {
+        return false;
+    };
+    let Some(grand_parent) = ctx.nodes().parent_node(parent.id()) else {
+        return false;
+    };
+    let AstKind::CallExpression(call_expr) = grand_parent.kind() else {
+        return false;
+    };
 
     if !std::ptr::eq(&call_expr.arguments[0], parent_call_expr_arg) {
         return false;
@@ -219,14 +219,20 @@ fn check_array_callback_methods(
     if callee_member_expr.optional() {
         return false;
     }
-    let Some(method_name) = callee_member_expr.static_property_name() else { return false };
+    let Some(method_name) = callee_member_expr.static_property_name() else {
+        return false;
+    };
     if !ARRAY_METHODS_WITH_BOOLEAN_CALLBACK.contains(method_name) {
         return false;
     }
 
-    let Some(first_param_name) = get_first_parameter_name(arg) else { return false };
+    let Some(first_param_name) = get_first_parameter_name(arg) else {
+        return false;
+    };
 
-    let Some(first_stmt) = function_body.statements.first() else { return false };
+    let Some(first_stmt) = function_body.statements.first() else {
+        return false;
+    };
 
     let Some(returned_ident) = get_returned_ident(first_stmt, is_arrow) else {
         return false;
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_node_protocol.rs b/crates/oxc_linter/src/rules/unicorn/prefer_node_protocol.rs
index 9248131ae516..d3392100df64 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_node_protocol.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_node_protocol.rs
@@ -2,20 +2,19 @@ use oxc_ast::{
     ast::{Expression, ModuleDeclaration},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_resolver::NODEJS_BUILTINS;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-node-protocol): Prefer using the `node:` protocol when importing Node.js builtin modules.")]
-#[diagnostic(severity(warning), help("Prefer `node:{1}` over `{1}`."))]
-struct PreferNodeProtocolDiagnostic(#[label] pub Span, String);
+fn prefer_node_protocol_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-node-protocol): Prefer using the `node:` protocol when importing Node.js builtin modules.")
+        .with_help(format!("Prefer `node:{x1}` over `{x1}`."))
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferNodeProtocol;
@@ -75,7 +74,7 @@ impl Rule for PreferNodeProtocol {
             return;
         }
 
-        ctx.diagnostic(PreferNodeProtocolDiagnostic(span, string_lit_value.to_string()));
+        ctx.diagnostic(prefer_node_protocol_diagnostic(span, &string_lit_value));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_number_properties.rs b/crates/oxc_linter/src/rules/unicorn/prefer_number_properties.rs
index cea4a69498eb..b19980dfe271 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_number_properties.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_number_properties.rs
@@ -2,21 +2,18 @@ use oxc_ast::{
     ast::{match_member_expression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, globals::GLOBAL_OBJECT_NAMES, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-unicorn(prefer-number-properties): Use `Number.{1}` instead of the global `{1}`"
-)]
-#[diagnostic(severity(warning), help("Replace it with `Number.{1}`"))]
-struct PreferNumberPropertiesDiagnostic(#[label] pub Span, pub String);
+fn prefer_number_properties_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(prefer-number-properties): Use `Number.{x1}` instead of the global `{x1}`"))
+        .with_help(format!("Replace it with `Number.{x1}`"))
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferNumberProperties;
@@ -63,15 +60,15 @@ impl Rule for PreferNumberProperties {
                 if GLOBAL_OBJECT_NAMES.contains(ident_name.name.as_str()) {
                     match member_expr.static_property_name() {
                         Some("NaN") => {
-                            ctx.diagnostic(PreferNumberPropertiesDiagnostic(
+                            ctx.diagnostic(prefer_number_properties_diagnostic(
                                 member_expr.span(),
-                                "NaN".to_string(),
+                                "NaN",
                             ));
                         }
                         Some("Infinity") => {
-                            ctx.diagnostic(PreferNumberPropertiesDiagnostic(
+                            ctx.diagnostic(prefer_number_properties_diagnostic(
                                 member_expr.span(),
-                                "Infinity".to_string(),
+                                "Infinity",
                             ));
                         }
                         _ => {}
@@ -80,9 +77,9 @@ impl Rule for PreferNumberProperties {
             }
             AstKind::IdentifierReference(ident_ref) => match ident_ref.name.as_str() {
                 "NaN" | "Infinity" => {
-                    ctx.diagnostic(PreferNumberPropertiesDiagnostic(
+                    ctx.diagnostic(prefer_number_properties_diagnostic(
                         ident_ref.span,
-                        ident_ref.name.to_string(),
+                        &ident_ref.name,
                     ));
                 }
                 _ => {}
@@ -97,9 +94,9 @@ impl Rule for PreferNumberProperties {
 
                 match ident_name.name.as_str() {
                     "NaN" | "Infinity" => {
-                        ctx.diagnostic(PreferNumberPropertiesDiagnostic(
+                        ctx.diagnostic(prefer_number_properties_diagnostic(
                             ident_name.span,
-                            ident_name.name.to_string(),
+                            &ident_name.name,
                         ));
                     }
                     _ => {}
@@ -111,9 +108,9 @@ impl Rule for PreferNumberProperties {
                 };
 
                 if matches!(ident_name, "isNaN" | "isFinite" | "parseFloat" | "parseInt") {
-                    ctx.diagnostic(PreferNumberPropertiesDiagnostic(
+                    ctx.diagnostic(prefer_number_properties_diagnostic(
                         call_expr.callee.span(),
-                        ident_name.to_string(),
+                        ident_name,
                     ));
                 }
             }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_optional_catch_binding.rs b/crates/oxc_linter/src/rules/unicorn/prefer_optional_catch_binding.rs
index dee733b77ff0..eae46dd0040a 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_optional_catch_binding.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_optional_catch_binding.rs
@@ -2,19 +2,16 @@ use oxc_ast::{
     ast::{BindingPattern, BindingPatternKind},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-optional-catch-binding): Prefer omitting the catch binding parameter if it is unused")]
-#[diagnostic(severity(warning))]
-struct PreferOptionalCatchBindingDiagnostic(#[label] pub Span);
+fn prefer_optional_catch_binding_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-optional-catch-binding): Prefer omitting the catch binding parameter if it is unused").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferOptionalCatchBinding;
@@ -46,12 +43,14 @@ declare_oxc_lint!(
 
 impl Rule for PreferOptionalCatchBinding {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CatchParameter(catch_param) = node.kind() else { return };
+        let AstKind::CatchParameter(catch_param) = node.kind() else {
+            return;
+        };
         let references_count = get_param_references_count(&catch_param.pattern, ctx);
         if references_count != 0 {
             return;
         }
-        ctx.diagnostic(PreferOptionalCatchBindingDiagnostic(catch_param.pattern.span()));
+        ctx.diagnostic(prefer_optional_catch_binding_diagnostic(catch_param.pattern.span()));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_prototype_methods.rs b/crates/oxc_linter/src/rules/unicorn/prefer_prototype_methods.rs
index aa3744f05c78..527fc5816fe0 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_prototype_methods.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_prototype_methods.rs
@@ -1,8 +1,5 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -14,14 +11,15 @@ use crate::{
     AstNode, Fix,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-enum PreferPrototypeMethodsDiagnostic {
-    #[error("eslint-plugin-unicorn(prefer-prototype-methods): Prefer using `{1}.prototype.{2}`.")]
-    #[diagnostic(severity(warning))]
-    KnownMethod(#[label] Span, &'static str, String),
-    #[error("eslint-plugin-unicorn(prefer-prototype-methods): Prefer using method from `{1}.prototype`.")]
-    #[diagnostic(severity(warning))]
-    UnknownMethod(#[label] Span, &'static str),
+fn known_method(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(prefer-prototype-methods): Prefer using `{x1}.prototype.{x2}`."
+    ))
+    .with_labels([span0.into()])
+}
+
+fn unknown_method(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(prefer-prototype-methods): Prefer using method from `{x1}.prototype`.")).with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -29,6 +27,7 @@ pub struct PreferPrototypeMethods;
 
 declare_oxc_lint!(
     /// ### What it does
+    ///
     /// This rule prefers borrowing methods from the prototype instead of the instance.
     ///
     /// ### Why is this bad?
@@ -53,7 +52,9 @@ declare_oxc_lint!(
 
 impl Rule for PreferPrototypeMethods {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
         if call_expr.optional {
             return;
@@ -82,8 +83,12 @@ impl Rule for PreferPrototypeMethods {
                 .map(|member_expr| member_expr.object().without_parenthesized());
         }
 
-        let Some(method_expr) = method_expr else { return };
-        let Some(method_expr) = method_expr.as_member_expression() else { return };
+        let Some(method_expr) = method_expr else {
+            return;
+        };
+        let Some(method_expr) = method_expr.as_member_expression() else {
+            return;
+        };
         let object_expr = method_expr.object().without_parenthesized();
 
         if !is_empty_array_expression(object_expr) && !is_empty_object_expression(object_expr) {
@@ -101,19 +106,8 @@ impl Rule for PreferPrototypeMethods {
 
         ctx.diagnostic_with_fix(
             method_name.map_or_else(
-                || {
-                    PreferPrototypeMethodsDiagnostic::UnknownMethod(
-                        method_expr.span(),
-                        constructor_name,
-                    )
-                },
-                |method_name| {
-                    PreferPrototypeMethodsDiagnostic::KnownMethod(
-                        method_expr.span(),
-                        constructor_name,
-                        method_name.into(),
-                    )
-                },
+                || unknown_method(method_expr.span(), constructor_name),
+                |method_name| known_method(method_expr.span(), constructor_name, method_name),
             ),
             || {
                 let span = object_expr.span();
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_query_selector.rs b/crates/oxc_linter/src/rules/unicorn/prefer_query_selector.rs
index 892f93a22de9..c290d6c242b7 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_query_selector.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_query_selector.rs
@@ -1,19 +1,17 @@
-use miette::diagnostic;
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use phf::phf_map;
 
 use crate::{context::LintContext, rule::Rule, utils::is_node_value_not_dom_node, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-query-selector): Prefer `.{0}()` over `.{1}()`.")]
-#[diagnostic(severity(Warning), help("It's better to use the same method to query DOM elements. This helps keep consistency and it lends itself to future improvements (e.g. more specific selectors)."))]
-struct PreferQuerySelectorDiagnostic(&'static str, &'static str, #[label] pub Span);
+fn prefer_query_selector_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(prefer-query-selector): Prefer `.{x0}()` over `.{x1}()`."))
+        .with_help("It's better to use the same method to query DOM elements. This helps keep consistency and it lends itself to future improvements (e.g. more specific selectors).")
+        .with_labels([span2.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferQuerySelector;
@@ -51,7 +49,9 @@ declare_oxc_lint!(
 
 impl Rule for PreferQuerySelector {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
         if call_expr.optional || call_expr.arguments.len() != 1 {
             return;
@@ -81,8 +81,11 @@ impl Rule for PreferQuerySelector {
                 continue;
             }
 
-            let diagnostic =
-                PreferQuerySelectorDiagnostic(preferred_selector, cur_property_name, property_span);
+            let diagnostic = prefer_query_selector_diagnostic(
+                preferred_selector,
+                cur_property_name,
+                property_span,
+            );
 
             if argument_expr.is_null() {
                 return ctx.diagnostic_with_fix(diagnostic, || {
@@ -111,12 +114,7 @@ impl Rule for PreferQuerySelector {
                     let source_text = argument_expr.span().source_text(ctx.source_text());
                     let quotes_symbol = source_text.chars().next().unwrap();
                     let sharp = if cur_property_name.eq(&"getElementById") { "#" } else { "" };
-                    return Fix::new(
-                        format!(
-                            "{preferred_selector}({quotes_symbol}{sharp}{literal_value}{quotes_symbol}"
-                        ),
-                        property_span.merge(&argument_expr.span()),
-                    );
+                    return Fix::new(format!("{preferred_selector}({quotes_symbol}{sharp}{literal_value}{quotes_symbol}"), property_span.merge(&argument_expr.span()));
                 });
             }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_reflect_apply.rs b/crates/oxc_linter/src/rules/unicorn/prefer_reflect_apply.rs
index 169d08e37093..a59c45f4bffd 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_reflect_apply.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_reflect_apply.rs
@@ -2,21 +2,20 @@ use oxc_ast::{
     ast::{Argument, Expression, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error(
-    "eslint-plugin-unicorn(prefer-reflect-apply): Prefer Reflect.apply() over Function#apply()"
-)]
-#[diagnostic(severity(warning), help("Reflect.apply() is less verbose and easier to understand."))]
-struct PreferReflectApplyDiagnostic(#[label] pub Span);
+fn prefer_reflect_apply_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning(
+        "eslint-plugin-unicorn(prefer-reflect-apply): Prefer Reflect.apply() over Function#apply()",
+    )
+    .with_help("Reflect.apply() is less verbose and easier to understand.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferReflectApply;
@@ -80,7 +79,7 @@ impl Rule for PreferReflectApply {
         if is_static_property_name_equal(member_expr, "apply")
             && matches!(call_expr.arguments.as_slice(), [first, second] if is_apply_signature(first, second))
         {
-            ctx.diagnostic(PreferReflectApplyDiagnostic(call_expr.span));
+            ctx.diagnostic(prefer_reflect_apply_diagnostic(call_expr.span));
             return;
         }
 
@@ -101,7 +100,7 @@ impl Rule for PreferReflectApply {
                     if iden.name == "Function"
                         && matches!(call_expr.arguments.as_slice(), [_, second, third] if is_apply_signature(second, third))
                     {
-                        ctx.diagnostic(PreferReflectApplyDiagnostic(call_expr.span));
+                        ctx.diagnostic(prefer_reflect_apply_diagnostic(call_expr.span));
                     }
                 }
             }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_regexp_test.rs b/crates/oxc_linter/src/rules/unicorn/prefer_regexp_test.rs
index 81790a546ff8..50a332fb2496 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_regexp_test.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_regexp_test.rs
@@ -2,22 +2,18 @@ use oxc_ast::{
     ast::{Expression, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{ast_util::outermost_paren_parent, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-regexp-test): Prefer RegExp#test() over String#match() and RegExp#exec()")]
-#[diagnostic(
-    severity(warning),
-    help("RegExp#test() exclusively returns a boolean and therefore is more efficient")
-)]
-struct PreferRegexpTestDiagnostic(#[label] pub Span);
+fn prefer_regexp_test_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-regexp-test): Prefer RegExp#test() over String#match() and RegExp#exec()")
+        .with_help("RegExp#test() exclusively returns a boolean and therefore is more efficient")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferRegexpTest;
@@ -49,9 +45,13 @@ declare_oxc_lint!(
 
 impl Rule for PreferRegexpTest {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
-        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
 
         if call_expr.optional || call_expr.arguments.len() != 1 {
             return;
@@ -71,7 +71,9 @@ impl Rule for PreferRegexpTest {
             _ => return,
         };
 
-        let Some(parent) = outermost_paren_parent(node, ctx) else { return };
+        let Some(parent) = outermost_paren_parent(node, ctx) else {
+            return;
+        };
 
         match parent.kind() {
             AstKind::ForStatement(for_stmt) => {
@@ -98,9 +100,13 @@ impl Rule for PreferRegexpTest {
             }
 
             AstKind::Argument(_) => {
-                let Some(parent) = outermost_paren_parent(parent, ctx) else { return };
+                let Some(parent) = outermost_paren_parent(parent, ctx) else {
+                    return;
+                };
 
-                let AstKind::CallExpression(call_expr) = parent.kind() else { return };
+                let AstKind::CallExpression(call_expr) = parent.kind() else {
+                    return;
+                };
 
                 let Expression::Identifier(ident) = &call_expr.callee else {
                     return;
@@ -141,7 +147,7 @@ impl Rule for PreferRegexpTest {
             _ => unreachable!("match or test {:?}", name),
         }
 
-        ctx.diagnostic(PreferRegexpTestDiagnostic(span));
+        ctx.diagnostic(prefer_regexp_test_diagnostic(span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_set_size.rs b/crates/oxc_linter/src/rules/unicorn/prefer_set_size.rs
index 9c67ab483596..a9ad83ec4b4a 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_set_size.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_set_size.rs
@@ -2,19 +2,16 @@ use oxc_ast::{
     ast::{ArrayExpressionElement, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
 use crate::{ast_util::get_declaration_of_variable, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-set-size): Use `Set#size` instead of converting a `Set` to an array and using its `length` property.")]
-#[diagnostic(severity(warning))]
-struct PreferSetSizeDiagnostic(#[label] pub Span);
+fn prefer_set_size_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-set-size): Use `Set#size` instead of converting a `Set` to an array and using its `length` property.").with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferSetSize;
@@ -74,7 +71,7 @@ impl Rule for PreferSetSize {
             return;
         }
 
-        ctx.diagnostic(PreferSetSizeDiagnostic(span));
+        ctx.diagnostic(prefer_set_size_diagnostic(span));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_spread.rs b/crates/oxc_linter/src/rules/unicorn/prefer_spread.rs
index ccc1fcb63b35..4359cf2c2dec 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_spread.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_spread.rs
@@ -2,20 +2,21 @@ use oxc_ast::{
     ast::{match_member_expression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use phf::phf_set;
 
 use crate::{context::LintContext, rule::Rule, AstNode, Fix};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-spread): Prefer the spread operator (`...`) over {1}")]
-#[diagnostic(severity(warning), help("The spread operator (`...`) is more concise and readable."))]
-struct PreferSpreadDiagnostic(#[label] pub Span, pub &'static str);
+fn prefer_spread_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(prefer-spread): Prefer the spread operator (`...`) over {x1}"
+    ))
+    .with_help("The spread operator (`...`) is more concise and readable.")
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferSpread;
@@ -44,14 +45,18 @@ declare_oxc_lint!(
 
 impl Rule for PreferSpread {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
         let Some(member_expr) = call_expr.callee.without_parenthesized().as_member_expression()
         else {
             return;
         };
 
-        let Some(static_property_name) = member_expr.static_property_name() else { return };
+        let Some(static_property_name) = member_expr.static_property_name() else {
+            return;
+        };
 
         match static_property_name {
             // `Array.from()`
@@ -60,7 +65,9 @@ impl Rule for PreferSpread {
                     return;
                 }
 
-                let Some(expr) = call_expr.arguments[0].as_expression() else { return };
+                let Some(expr) = call_expr.arguments[0].as_expression() else {
+                    return;
+                };
                 if matches!(expr.without_parenthesized(), Expression::ObjectExpression(_)) {
                     return;
                 }
@@ -74,7 +81,7 @@ impl Rule for PreferSpread {
                     return;
                 }
 
-                ctx.diagnostic(PreferSpreadDiagnostic(call_expr.span, "Array.from()"));
+                ctx.diagnostic(prefer_spread_diagnostic(call_expr.span, "Array.from()"));
             }
             // `array.concat()`
             "concat" => {
@@ -82,7 +89,7 @@ impl Rule for PreferSpread {
                     return;
                 }
 
-                ctx.diagnostic(PreferSpreadDiagnostic(call_expr.span, "array.concat()"));
+                ctx.diagnostic(prefer_spread_diagnostic(call_expr.span, "array.concat()"));
             }
             // `array.slice()`
             "slice" => {
@@ -106,7 +113,9 @@ impl Rule for PreferSpread {
                 }
 
                 if let Some(first_arg) = call_expr.arguments.first() {
-                    let Some(first_arg) = first_arg.as_expression() else { return };
+                    let Some(first_arg) = first_arg.as_expression() else {
+                        return;
+                    };
                     if let Expression::NumericLiteral(num_lit) = first_arg.without_parenthesized() {
                         if num_lit.value != 0.0 {
                             return;
@@ -116,7 +125,7 @@ impl Rule for PreferSpread {
                     }
                 }
 
-                ctx.diagnostic(PreferSpreadDiagnostic(call_expr.span, "array.slice()"));
+                ctx.diagnostic(prefer_spread_diagnostic(call_expr.span, "array.slice()"));
             }
             // `array.toSpliced()`
             "toSpliced" => {
@@ -131,7 +140,7 @@ impl Rule for PreferSpread {
                     return;
                 }
 
-                ctx.diagnostic(PreferSpreadDiagnostic(call_expr.span, "array.toSpliced()"));
+                ctx.diagnostic(prefer_spread_diagnostic(call_expr.span, "array.toSpliced()"));
             }
             // `string.split()`
             "split" => {
@@ -139,7 +148,9 @@ impl Rule for PreferSpread {
                     return;
                 }
 
-                let Some(expr) = call_expr.arguments[0].as_expression() else { return };
+                let Some(expr) = call_expr.arguments[0].as_expression() else {
+                    return;
+                };
                 let Expression::StringLiteral(string_lit) = expr.without_parenthesized() else {
                     return;
                 };
@@ -149,7 +160,7 @@ impl Rule for PreferSpread {
                 }
 
                 ctx.diagnostic_with_fix(
-                    PreferSpreadDiagnostic(call_expr.span, "string.split()"),
+                    prefer_spread_diagnostic(call_expr.span, "string.split()"),
                     || {
                         let callee_obj = member_expr.object().without_parenthesized();
                         Fix::new(
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_string_replace_all.rs b/crates/oxc_linter/src/rules/unicorn/prefer_string_replace_all.rs
index 0b5a83dfca15..2f1519662f3b 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_string_replace_all.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_string_replace_all.rs
@@ -2,23 +2,19 @@ use oxc_ast::{
     ast::{Argument, MemberExpression, RegExpFlags},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{CompactStr, Span};
 
 use crate::{ast_util::extract_regex_flags, context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum PreferStringReplaceAllDiagnostic {
-    #[error("eslint-plugin-unicorn(prefer-string-replace-all): This pattern can be replaced with `{1}`.")]
-    #[diagnostic(severity(warning))]
-    StringLiteral(#[label] Span, CompactStr),
-    #[error("eslint-plugin-unicorn(prefer-string-replace-all): Prefer `String#replaceAll()` over `String#replace()` when using a regex with the global flag.")]
-    #[diagnostic(severity(warning))]
-    UseReplaceAll(#[label] Span),
+fn string_literal(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!("eslint-plugin-unicorn(prefer-string-replace-all): This pattern can be replaced with `{x1}`.")).with_labels([span0.into()])
+}
+
+fn use_replace_all(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-string-replace-all): Prefer `String#replaceAll()` over `String#replace()` when using a regex with the global flag.")
+        .with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -42,9 +38,13 @@ declare_oxc_lint!(
 
 impl Rule for PreferStringReplaceAll {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
-        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
 
         let MemberExpression::StaticMemberExpression(static_member_expr) = member_expr else {
             return;
@@ -64,16 +64,11 @@ impl Rule for PreferStringReplaceAll {
         match method_name_str {
             "replaceAll" => {
                 if let Some(k) = get_pattern_replacement(pattern) {
-                    ctx.diagnostic(PreferStringReplaceAllDiagnostic::StringLiteral(
-                        static_member_expr.property.span,
-                        k,
-                    ));
+                    ctx.diagnostic(string_literal(static_member_expr.property.span, &k));
                 }
             }
             "replace" if is_reg_exp_with_global_flag(pattern) => {
-                ctx.diagnostic(PreferStringReplaceAllDiagnostic::UseReplaceAll(
-                    static_member_expr.property.span,
-                ));
+                ctx.diagnostic(use_replace_all(static_member_expr.property.span));
             }
             _ => {}
         }
@@ -99,7 +94,9 @@ fn is_reg_exp_with_global_flag<'a>(expr: &'a Argument<'a>) -> bool {
 }
 
 fn get_pattern_replacement<'a>(expr: &'a Argument<'a>) -> Option<CompactStr> {
-    let Argument::RegExpLiteral(reg_exp_literal) = expr else { return None };
+    let Argument::RegExpLiteral(reg_exp_literal) = expr else {
+        return None;
+    };
 
     if !reg_exp_literal.regex.flags.contains(RegExpFlags::G) {
         return None;
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_string_slice.rs b/crates/oxc_linter/src/rules/unicorn/prefer_string_slice.rs
index 79d8153d1cd6..58d5bc93f186 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_string_slice.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_string_slice.rs
@@ -1,17 +1,17 @@
 use oxc_ast::{ast::MemberExpression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-string-slice): Prefer String#slice() over String#{1}()")]
-#[diagnostic(severity(warning))]
-struct PreferStringSliceDiagnostic(#[label] pub Span, CompactStr);
+fn prefer_string_slice_diagnostic(span0: Span, x1: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(prefer-string-slice): Prefer String#slice() over String#{x1}()"
+    ))
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferStringSlice;
@@ -38,7 +38,9 @@ impl Rule for PreferStringSlice {
             return;
         };
 
-        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
 
         let (span, name) = match member_expr {
             MemberExpression::StaticMemberExpression(v) => {
@@ -50,7 +52,7 @@ impl Rule for PreferStringSlice {
             _ => return,
         };
 
-        ctx.diagnostic(PreferStringSliceDiagnostic(span, name.to_compact_str()));
+        ctx.diagnostic(prefer_string_slice_diagnostic(span, name.as_str()));
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_string_starts_ends_with.rs b/crates/oxc_linter/src/rules/unicorn/prefer_string_starts_ends_with.rs
index cb6c28a720ad..bc9e8565c74c 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_string_starts_ends_with.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_string_starts_ends_with.rs
@@ -2,23 +2,18 @@ use oxc_ast::{
     ast::{Expression, MemberExpression, RegExpFlags, RegExpLiteral},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-enum PreferStringStartsEndsWithDiagnostic {
-    #[error("eslint-plugin-unicorn(prefer-string-starts-ends-with): Prefer String#startsWith over a regex with a caret.")]
-    #[diagnostic(severity(warning))]
-    StartsWith(#[label] Span),
-    #[error("eslint-plugin-unicorn(prefer-string-starts-ends-with): Prefer String#endsWith over a regex with a dollar sign.")]
-    #[diagnostic(severity(warning))]
-    EndsWith(#[label] Span),
+fn starts_with(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-string-starts-ends-with): Prefer String#startsWith over a regex with a caret.").with_labels([span0.into()])
+}
+
+fn ends_with(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-string-starts-ends-with): Prefer String#endsWith over a regex with a dollar sign.").with_labels([span0.into()])
 }
 
 #[derive(Debug, Default, Clone)]
@@ -57,7 +52,9 @@ impl Rule for PreferStringStartsEndsWith {
             return;
         }
 
-        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
 
         let MemberExpression::StaticMemberExpression(static_member_expr) = &member_expr else {
             return;
@@ -71,16 +68,16 @@ impl Rule for PreferStringStartsEndsWith {
             return;
         };
 
-        let Some(err_kind) = check_regex(regex) else { return };
+        let Some(err_kind) = check_regex(regex) else {
+            return;
+        };
 
         match err_kind {
             ErrorKind::StartsWith => {
-                ctx.diagnostic(PreferStringStartsEndsWithDiagnostic::StartsWith(
-                    member_expr.span(),
-                ));
+                ctx.diagnostic(starts_with(member_expr.span()));
             }
             ErrorKind::EndsWith => {
-                ctx.diagnostic(PreferStringStartsEndsWithDiagnostic::EndsWith(member_expr.span()));
+                ctx.diagnostic(ends_with(member_expr.span()));
             }
         }
     }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_string_trim_start_end.rs b/crates/oxc_linter/src/rules/unicorn/prefer_string_trim_start_end.rs
index 6833b551e3bc..6610f0995ae7 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_string_trim_start_end.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_string_trim_start_end.rs
@@ -1,17 +1,18 @@
 use oxc_ast::{ast::MemberExpression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-string-trim-start-end): Prefer `{1}` over `{2}`")]
-#[diagnostic(severity(warning), help("Replace with `{1}`"))]
-struct PreferStringTrimStartEndDiagnostic(#[label] pub Span, CompactStr, &'static str);
+fn prefer_string_trim_start_end_diagnostic(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(prefer-string-trim-start-end): Prefer `{x1}` over `{x2}`"
+    ))
+    .with_help(format!("Replace with `{x1}`"))
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferStringTrimStartEnd;
@@ -49,7 +50,9 @@ impl Rule for PreferStringTrimStartEnd {
             return;
         }
 
-        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };
+        let Some(member_expr) = call_expr.callee.get_member_expr() else {
+            return;
+        };
 
         let (span, name) = match member_expr {
             MemberExpression::StaticMemberExpression(v) => {
@@ -65,9 +68,9 @@ impl Rule for PreferStringTrimStartEnd {
             return;
         }
 
-        ctx.diagnostic(PreferStringTrimStartEndDiagnostic(
+        ctx.diagnostic(prefer_string_trim_start_end_diagnostic(
             span,
-            name.to_compact_str(),
+            name.as_str(),
             get_replacement(name.as_str()),
         ));
     }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_type_error.rs b/crates/oxc_linter/src/rules/unicorn/prefer_type_error.rs
index 633e453890d9..0891d2cefe96 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_type_error.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_type_error.rs
@@ -2,20 +2,19 @@ use oxc_ast::{
     ast::{match_member_expression, CallExpression, Expression, MemberExpression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{BinaryOperator, UnaryOperator};
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(prefer-type-error): Prefer throwing a `TypeError` over a generic `Error` after a type checking if-statement")]
-#[diagnostic(severity(warning), help("Change to `throw new TypeError(...)`"))]
-struct PreferTypeErrorDiagnostic(#[label] pub Span);
+fn prefer_type_error_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(prefer-type-error): Prefer throwing a `TypeError` over a generic `Error` after a type checking if-statement")
+        .with_help("Change to `throw new TypeError(...)`")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct PreferTypeError;
@@ -47,7 +46,9 @@ declare_oxc_lint!(
 
 impl Rule for PreferTypeError {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::ThrowStatement(throw_stmt) = node.kind() else { return };
+        let AstKind::ThrowStatement(throw_stmt) = node.kind() else {
+            return;
+        };
 
         let Expression::NewExpression(new_expr) = &throw_stmt.argument.without_parenthesized()
         else {
@@ -58,20 +59,28 @@ impl Rule for PreferTypeError {
             return;
         }
 
-        let Some(parent) = ctx.nodes().parent_node(node.id()) else { return };
+        let Some(parent) = ctx.nodes().parent_node(node.id()) else {
+            return;
+        };
 
-        let AstKind::BlockStatement(block_stmt) = parent.kind() else { return };
+        let AstKind::BlockStatement(block_stmt) = parent.kind() else {
+            return;
+        };
 
         if block_stmt.body.len() != 1 {
             return;
         }
 
-        let Some(parent) = ctx.nodes().parent_node(parent.id()) else { return };
+        let Some(parent) = ctx.nodes().parent_node(parent.id()) else {
+            return;
+        };
 
-        let AstKind::IfStatement(if_stmt) = parent.kind() else { return };
+        let AstKind::IfStatement(if_stmt) = parent.kind() else {
+            return;
+        };
 
         if is_type_checking_expr(&if_stmt.test) {
-            ctx.diagnostic(PreferTypeErrorDiagnostic(new_expr.callee.span()));
+            ctx.diagnostic(prefer_type_error_diagnostic(new_expr.callee.span()));
         }
     }
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/require_array_join_separator.rs b/crates/oxc_linter/src/rules/unicorn/require_array_join_separator.rs
index 63340576778d..8f24a18ee777 100644
--- a/crates/oxc_linter/src/rules/unicorn/require_array_join_separator.rs
+++ b/crates/oxc_linter/src/rules/unicorn/require_array_join_separator.rs
@@ -1,8 +1,6 @@
 use oxc_ast::{ast::MemberExpression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
@@ -11,10 +9,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(require-array-join-separator): Enforce using the separator argument with Array#join()")]
-#[diagnostic(severity(warning), help("Missing the separator argument."))]
-struct RequireArrayJoinSeparatorDiagnostic(#[label] pub Span);
+fn require_array_join_separator_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(require-array-join-separator): Enforce using the separator argument with Array#join()")
+        .with_help("Missing the separator argument.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct RequireArrayJoinSeparator;
@@ -60,7 +59,7 @@ impl Rule for RequireArrayJoinSeparator {
             && !call_expr.optional
             && !matches!(member_expr, MemberExpression::ComputedMemberExpression(_))
         {
-            ctx.diagnostic(RequireArrayJoinSeparatorDiagnostic(Span::new(
+            ctx.diagnostic(require_array_join_separator_diagnostic(Span::new(
                 member_expr.span().end,
                 call_expr.span.end,
             )));
@@ -74,7 +73,7 @@ impl Rule for RequireArrayJoinSeparator {
                 && !call_expr.arguments.iter().any(oxc_ast::ast::Argument::is_spread)
                 && is_array_prototype_property(member_expr_obj, "join")
             {
-                ctx.diagnostic(RequireArrayJoinSeparatorDiagnostic(Span::new(
+                ctx.diagnostic(require_array_join_separator_diagnostic(Span::new(
                     member_expr.span().end,
                     call_expr.span.end,
                 )));
diff --git a/crates/oxc_linter/src/rules/unicorn/require_number_to_fixed_digits_argument.rs b/crates/oxc_linter/src/rules/unicorn/require_number_to_fixed_digits_argument.rs
index 77dfdcfc8216..8a655b1c3ceb 100644
--- a/crates/oxc_linter/src/rules/unicorn/require_number_to_fixed_digits_argument.rs
+++ b/crates/oxc_linter/src/rules/unicorn/require_number_to_fixed_digits_argument.rs
@@ -1,17 +1,16 @@
 use oxc_ast::{ast::Expression, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(require-number-to-fixed-digits-argument): Number method .toFixed() should have an argument")]
-#[diagnostic(severity(warning), help("It's better to make it clear what the value of the digits argument is when calling Number#toFixed(), instead of relying on the default value of 0."))]
-struct RequireNumberToFixedDigitsArgumentDiagnostic(#[label] pub Span);
+fn require_number_to_fixed_digits_argument_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(require-number-to-fixed-digits-argument): Number method .toFixed() should have an argument")
+        .with_help("It's better to make it clear what the value of the digits argument is when calling Number#toFixed(), instead of relying on the default value of 0.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct RequireNumberToFixedDigitsArgument;
@@ -61,7 +60,7 @@ impl Rule for RequireNumberToFixedDigitsArgument {
                     let parenthesis_span = Span::new(member.span().end, expr.span.end);
 
                     ctx.diagnostic_with_fix(
-                        RequireNumberToFixedDigitsArgumentDiagnostic(parenthesis_span),
+                        require_number_to_fixed_digits_argument_diagnostic(parenthesis_span),
                         || {
                             let modified_code = {
                                 let mut formatter = ctx.codegen();
diff --git a/crates/oxc_linter/src/rules/unicorn/switch_case_braces.rs b/crates/oxc_linter/src/rules/unicorn/switch_case_braces.rs
index 14c059cb9f77..82a149443a76 100644
--- a/crates/oxc_linter/src/rules/unicorn/switch_case_braces.rs
+++ b/crates/oxc_linter/src/rules/unicorn/switch_case_braces.rs
@@ -1,20 +1,16 @@
 use oxc_ast::{ast::Statement, AstKind};
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, fixer::Fix, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(switch-case-braces):  Empty switch case shouldn't have braces and not-empty case should have braces around it.")]
-#[diagnostic(
-    severity(warning),
-    help("There is less visual clutter for empty cases and proper scope for non-empty cases.")
-)]
-struct SwitchCaseBracesDiagnostic(#[label] pub Span);
+fn switch_case_braces_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(switch-case-braces):  Empty switch case shouldn't have braces and not-empty case should have braces around it.")
+        .with_help("There is less visual clutter for empty cases and proper scope for non-empty cases.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct SwitchCaseBraces;
@@ -43,7 +39,9 @@ declare_oxc_lint!(
 
 impl Rule for SwitchCaseBraces {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::SwitchStatement(switch) = node.kind() else { return };
+        let AstKind::SwitchStatement(switch) = node.kind() else {
+            return;
+        };
 
         if switch.cases.is_empty() {
             return;
@@ -55,7 +53,7 @@ impl Rule for SwitchCaseBraces {
                     Statement::BlockStatement(case_block) => {
                         if case_block.body.is_empty() {
                             ctx.diagnostic_with_fix(
-                                SwitchCaseBracesDiagnostic(case_block.span),
+                                switch_case_braces_diagnostic(case_block.span),
                                 || Fix::new("", case_block.span),
                             );
                         }
@@ -72,31 +70,34 @@ impl Rule for SwitchCaseBraces {
                         let case_body_span =
                             Span::new(first_statement.span().start, last_statement.span().end);
 
-                        ctx.diagnostic_with_fix(SwitchCaseBracesDiagnostic(case_body_span), || {
-                            use oxc_codegen::{Context, Gen};
-                            let modified_code = {
-                                let mut formatter = ctx.codegen();
-
-                                if let Some(case_test) = &case.test {
-                                    formatter.print_str(b"case ");
-                                    formatter.print_expression(case_test);
-                                } else {
-                                    formatter.print_str(b"default");
-                                }
-
-                                formatter.print_colon();
-                                formatter.print_hard_space();
-                                formatter.print(b'{');
-                                case.consequent
-                                    .iter()
-                                    .for_each(|x| x.gen(&mut formatter, Context::default()));
-                                formatter.print(b'}');
-
-                                formatter.into_source_text()
-                            };
-
-                            Fix::new(modified_code, case.span)
-                        });
+                        ctx.diagnostic_with_fix(
+                            switch_case_braces_diagnostic(case_body_span),
+                            || {
+                                use oxc_codegen::{Context, Gen};
+                                let modified_code = {
+                                    let mut formatter = ctx.codegen();
+
+                                    if let Some(case_test) = &case.test {
+                                        formatter.print_str(b"case ");
+                                        formatter.print_expression(case_test);
+                                    } else {
+                                        formatter.print_str(b"default");
+                                    }
+
+                                    formatter.print_colon();
+                                    formatter.print_hard_space();
+                                    formatter.print(b'{');
+                                    case.consequent
+                                        .iter()
+                                        .for_each(|x| x.gen(&mut formatter, Context::default()));
+                                    formatter.print(b'}');
+
+                                    formatter.into_source_text()
+                                };
+
+                                Fix::new(modified_code, case.span)
+                            },
+                        );
 
                         // After first incorrect consequent we have to break to not repeat the work
                         break;
@@ -129,7 +130,6 @@ fn test() {
         "switch(foo) { case 1: { doSomething(); } break; /* <-- This should be between braces */ }",
         "switch(foo) { default: label: {} }",
         "switch(something) { case 1: case 2: { console.log('something'); break; } case 3: console.log('something else'); }",
-
     ];
 
     let fix = vec![
diff --git a/crates/oxc_linter/src/rules/unicorn/text_encoding_identifier_case.rs b/crates/oxc_linter/src/rules/unicorn/text_encoding_identifier_case.rs
index 6b48e01a2807..f7047b3d37ea 100644
--- a/crates/oxc_linter/src/rules/unicorn/text_encoding_identifier_case.rs
+++ b/crates/oxc_linter/src/rules/unicorn/text_encoding_identifier_case.rs
@@ -2,20 +2,20 @@ use oxc_ast::{
     ast::{JSXAttributeItem, JSXAttributeName, JSXElementName},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::{self, Error},
-};
+use oxc_diagnostics::OxcDiagnostic;
+
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNodeId;
-use oxc_span::{CompactStr, Span};
+use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule, AstNode};
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(text-encoding-identifier-case): Prefer `{1}` over `{2}`.")]
-#[diagnostic(severity(warning))]
-struct TextEncodingIdentifierCaseDiagnostic(#[label] pub Span, pub &'static str, pub CompactStr);
+fn text_encoding_identifier_case_diagnostic(span0: Span, x1: &str, x2: &str) -> OxcDiagnostic {
+    OxcDiagnostic::warning(format!(
+        "eslint-plugin-unicorn(text-encoding-identifier-case): Prefer `{x1}` over `{x2}`."
+    ))
+    .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct TextEncodingIdentifierCase;
@@ -73,7 +73,7 @@ impl Rule for TextEncodingIdentifierCase {
             return;
         }
 
-        ctx.diagnostic(TextEncodingIdentifierCaseDiagnostic(span, replacement, s.into()));
+        ctx.diagnostic(text_encoding_identifier_case_diagnostic(span, replacement, s));
     }
 }
 
@@ -96,13 +96,17 @@ fn get_replacement(node: &str) -> Option<&'static str> {
 }
 
 fn is_jsx_meta_elem_with_charset_attr(id: AstNodeId, ctx: &LintContext) -> bool {
-    let Some(parent) = ctx.nodes().parent_node(id) else { return false };
+    let Some(parent) = ctx.nodes().parent_node(id) else {
+        return false;
+    };
 
     let AstKind::JSXAttributeItem(JSXAttributeItem::Attribute(jsx_attr)) = parent.kind() else {
         return false;
     };
 
-    let JSXAttributeName::Identifier(ident) = &jsx_attr.name else { return false };
+    let JSXAttributeName::Identifier(ident) = &jsx_attr.name else {
+        return false;
+    };
     if ident.name.to_lowercase() != "charset" {
         return false;
     }
@@ -112,7 +116,9 @@ fn is_jsx_meta_elem_with_charset_attr(id: AstNodeId, ctx: &LintContext) -> bool
         return false;
     };
 
-    let JSXElementName::Identifier(name) = &opening_elem.name else { return false };
+    let JSXElementName::Identifier(name) = &opening_elem.name else {
+        return false;
+    };
 
     if name.name.to_lowercase() != "meta" {
         return false;
diff --git a/crates/oxc_linter/src/rules/unicorn/throw_new_error.rs b/crates/oxc_linter/src/rules/unicorn/throw_new_error.rs
index 8a6c80aaa8fa..61e0e8fb71c6 100644
--- a/crates/oxc_linter/src/rules/unicorn/throw_new_error.rs
+++ b/crates/oxc_linter/src/rules/unicorn/throw_new_error.rs
@@ -3,10 +3,7 @@ use oxc_ast::{
     ast::{match_member_expression, Expression},
     AstKind,
 };
-use oxc_diagnostics::{
-    miette::{self, Diagnostic},
-    thiserror::Error,
-};
+use oxc_diagnostics::OxcDiagnostic;
 
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
@@ -19,10 +16,11 @@ use crate::{
     AstNode,
 };
 
-#[derive(Debug, Error, Diagnostic)]
-#[error("eslint-plugin-unicorn(throw-new-error): Require `new` when throwing an error.")]
-#[diagnostic(severity(warning), help("While it's possible to create a new error without using the `new` keyword, it's better to be explicit."))]
-struct ThrowNewErrorDiagnostic(#[label] pub Span);
+fn throw_new_error_diagnostic(span0: Span) -> OxcDiagnostic {
+    OxcDiagnostic::warning("eslint-plugin-unicorn(throw-new-error): Require `new` when throwing an error.")
+        .with_help("While it's possible to create a new error without using the `new` keyword, it's better to be explicit.")
+        .with_labels([span0.into()])
+}
 
 #[derive(Debug, Default, Clone)]
 pub struct ThrowNewError;
@@ -55,9 +53,13 @@ declare_oxc_lint!(
 
 impl Rule for ThrowNewError {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let AstKind::CallExpression(call_expr) = node.kind() else { return };
+        let AstKind::CallExpression(call_expr) = node.kind() else {
+            return;
+        };
 
-        let Some(outermost_paren_node) = outermost_paren_parent(node, ctx) else { return };
+        let Some(outermost_paren_node) = outermost_paren_parent(node, ctx) else {
+            return;
+        };
 
         let AstKind::ThrowStatement(_) = outermost_paren(outermost_paren_node, ctx).kind() else {
             return;
@@ -83,7 +85,7 @@ impl Rule for ThrowNewError {
             _ => return,
         }
 
-        ctx.diagnostic(ThrowNewErrorDiagnostic(call_expr.span));
+        ctx.diagnostic(throw_new_error_diagnostic(call_expr.span));
     }
 }
 
diff --git a/crates/oxc_linter/src/service.rs b/crates/oxc_linter/src/service.rs
index 02cf94bcb535..9c66acf52a75 100644
--- a/crates/oxc_linter/src/service.rs
+++ b/crates/oxc_linter/src/service.rs
@@ -293,7 +293,9 @@ impl Runtime {
                 .for_each_with(tx_error, |tx_error, (specifier, resolution)| {
                     let path = resolution.path();
                     self.process_path(path, tx_error);
-                    let Some(target_module_record_ref) = self.module_map.get(path) else { return };
+                    let Some(target_module_record_ref) = self.module_map.get(path) else {
+                        return;
+                    };
                     let ModuleState::Resolved(target_module_record) =
                         target_module_record_ref.value()
                     else {
diff --git a/crates/oxc_linter/src/snapshots/array_callback_return.snap b/crates/oxc_linter/src/snapshots/array_callback_return.snap
index aa51e8c58934..dd7801cef108 100644
--- a/crates/oxc_linter/src/snapshots/array_callback_return.snap
+++ b/crates/oxc_linter/src/snapshots/array_callback_return.snap
@@ -478,110 +478,110 @@ expression: array_callback_return
    ╰────
   help: Array method "Array.prototype.toSorted" needs to have valid return on all code paths
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:18]
  1 │ foo.forEach(x => x)
    ·                  ─
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:25]
  1 │ foo.forEach(function(x) { if (a == b) {return x;}})
    ·                         ──────────────────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:29]
  1 │ foo.forEach(function bar(x) { return x;})
    ·                             ────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:18]
  1 │ foo.forEach(x => x)
    ·                  ─
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:20]
  1 │ foo.forEach(val => y += val)
    ·                    ────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:28]
  1 │ ["foo","bar"].forEach(x => ++x)
    ·                            ───
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:24]
  1 │ foo.bar().forEach(x => x === y)
    ·                        ───────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:43]
  1 │ foo.forEach(function() {return function() { if (a == b) { return a; }}}())
    ·                                           ────────────────────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:25]
  1 │ foo.forEach(function(x) { if (a == b) {return x;}})
    ·                         ──────────────────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:25]
  1 │ foo.forEach(function(x) { if (a == b) {return undefined;}})
    ·                         ──────────────────────────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:29]
  1 │ foo.forEach(function bar(x) { return x;})
    ·                             ────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:29]
  1 │ foo.forEach(function bar(x) { return x;})
    ·                             ────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:35]
  1 │ foo.bar().forEach(function bar(x) { return x;})
    ·                                   ────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:39]
  1 │ ["foo","bar"].forEach(function bar(x) { return x;})
    ·                                       ────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:20]
  1 │ foo.forEach((x) => { return x;})
    ·                    ────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
   ⚠ eslint(array-callback-return): Missing return on some path for array method "Array.from"
    ╭─[array_callback_return.tsx:1:26]
@@ -654,34 +654,34 @@ expression: array_callback_return
    ╰────
   help: Array method "Array.from" needs to have valid return on all code paths
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:20]
  1 │ foo.forEach(bar => bar)
    ·                    ───
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:44]
  1 │ foo.forEach((function () { return (bar) => bar; })())
    ·                                            ───
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:2:16]
  1 │ foo.forEach((() => {
  2 │  return bar => bar; })())
    ·                ───
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:22]
  1 │ foo.forEach((bar) => { if (bar) { return; } else { return bar ; } })
    ·                      ──────────────────────────────────────────────
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
   ⚠ eslint(array-callback-return): Missing return on some path for array method "Array.prototype.filter"
    ╭─[array_callback_return.tsx:1:22]
@@ -748,14 +748,14 @@ expression: array_callback_return
    ╰────
   help: Array method "Array.prototype.filter" needs to have valid return on all code paths
 
-  ⚠ eslint(array-callback-return): Unexpected return for array method Array.prototype.forEach
+  ⚠ eslint(array-callback-return): Unexpected return for array method "Array.prototype.forEach"
    ╭─[array_callback_return.tsx:1:25]
  1 │ ╭─▶ foo.forEach(function () { 
  2 │ │   if (baz) return bar
  3 │ │   else return
  4 │ ╰─▶  })
    ╰────
-  help: Array method Array.prototype.forEach expects no useless return from the function
+  help: Array method "Array.prototype.forEach" expects no useless return from the function
 
   ⚠ eslint(array-callback-return): Missing return on some path for array method "Array.prototype.filter"
    ╭─[array_callback_return.tsx:1:19]
diff --git a/crates/oxc_linter/src/snapshots/max_lines.snap b/crates/oxc_linter/src/snapshots/max_lines.snap
index e0dfd3416876..e18985349478 100644
--- a/crates/oxc_linter/src/snapshots/max_lines.snap
+++ b/crates/oxc_linter/src/snapshots/max_lines.snap
@@ -28,9 +28,9 @@ expression: max_lines
 
   ⚠ eslint(max-lines): "File has too many lines (5). Maximum allowed is 2."
    ╭─[max_lines.tsx:3:1]
- 2 │                 
- 3 │ ╭─▶             
- 4 │ │               
+ 2 │     
+ 3 │ ╭─▶ 
+ 4 │ │   
  5 │ ╰─▶             var y;
    ╰────
   help: Reduce the number of lines in this file
@@ -38,9 +38,9 @@ expression: max_lines
   ⚠ eslint(max-lines): "File has too many lines (8). Maximum allowed is 2."
    ╭─[max_lines.tsx:3:1]
  2 │                 var xy;
- 3 │ ╭─▶              
+ 3 │ ╭─▶ 
  4 │ │               var xy;
- 5 │ │                
+ 5 │ │   
  6 │ │                /* a multiline
  7 │ │                really really
  8 │ ╰─▶              long comment*/
@@ -66,9 +66,9 @@ expression: max_lines
   ⚠ eslint(max-lines): "File has too many lines (8). Maximum allowed is 2."
    ╭─[max_lines.tsx:3:1]
  2 │                 var xy;
- 3 │ ╭─▶              
+ 3 │ ╭─▶ 
  4 │ │               var xy;
- 5 │ │                
+ 5 │ │   
  6 │ │                /* a multiline
  7 │ │                really really
  8 │ ╰─▶              long comment*/
@@ -126,7 +126,7 @@ expression: max_lines
   ⚠ eslint(max-lines): "File has too many lines (3). Maximum allowed is 1."
    ╭─[max_lines.tsx:2:1]
  1 │     A
- 2 │ ╭─▶             
+ 2 │ ╭─▶ 
  3 │ ╰─▶             
    ╰────
   help: Reduce the number of lines in this file
@@ -157,7 +157,7 @@ expression: max_lines
 
   ⚠ eslint(max-lines): "File has too many lines (6). Maximum allowed is 2."
    ╭─[max_lines.tsx:3:1]
- 2 │                 
+ 2 │     
  3 │ ╭─▶             var a = 'a',
  4 │ │               c,
  5 │ │               x;
@@ -170,7 +170,7 @@ expression: max_lines
  2 │                 var x
  3 │ ╭─▶             var c;
  4 │ │               console.log
- 5 │ │               // some block 
+ 5 │ │               // some block
  6 │ ╰─▶             // comments
    ╰────
   help: Reduce the number of lines in this file
@@ -199,16 +199,16 @@ expression: max_lines
  2 │                 var x
  3 │ ╭─▶             var c;
  4 │ │               console.log
- 5 │ │               /** block 
- 6 │ │               
+ 5 │ │               /** block
+ 6 │ │   
  7 │ ╰─▶              comments */
    ╰────
   help: Reduce the number of lines in this file
 
   ⚠ eslint(max-lines): "File has too many lines (4). Maximum allowed is 2."
    ╭─[max_lines.tsx:3:1]
- 2 │                 
- 3 │ ╭─▶             
+ 2 │     
+ 3 │ ╭─▶ 
  4 │ ╰─▶             // comment
    ╰────
   help: Reduce the number of lines in this file
@@ -216,23 +216,23 @@ expression: max_lines
   ⚠ eslint(max-lines): "File has too many lines (8). Maximum allowed is 2."
    ╭─[max_lines.tsx:3:1]
  2 │                 var x
- 3 │ ╭─▶             
- 4 │ │               
+ 3 │ ╭─▶ 
+ 4 │ │   
  5 │ │               var c;
  6 │ │               console.log
- 7 │ │               
+ 7 │ │   
  8 │ ╰─▶             
    ╰────
   help: Reduce the number of lines in this file
 
   ⚠ eslint(max-lines): "File has too many lines (8). Maximum allowed is 2."
    ╭─[max_lines.tsx:3:1]
- 2 │                 
- 3 │ ╭─▶             
+ 2 │     
+ 3 │ ╭─▶ 
  4 │ │               var x
  5 │ │               var c;
  6 │ │               console.log
- 7 │ │               
+ 7 │ │   
  8 │ ╰─▶             
    ╰────
   help: Reduce the number of lines in this file
@@ -263,14 +263,14 @@ expression: max_lines
   ⚠ eslint(max-lines): "File has too many lines (11). Maximum allowed is 2."
     ╭─[max_lines.tsx:3:1]
   2 │                 var x = '';
-  3 │ ╭─▶             
+  3 │ ╭─▶ 
   4 │ │               // comment
-  5 │ │               
+  5 │ │   
   6 │ │               var b = '',
   7 │ │               c,
   8 │ │               d,
   9 │ │               e
- 10 │ │               
+ 10 │ │   
  11 │ ╰─▶             // comment
     ╰────
   help: Reduce the number of lines in this file
diff --git a/crates/oxc_linter/src/snapshots/namespace.snap b/crates/oxc_linter/src/snapshots/namespace.snap
index bf465ade66e0..cc433db2b35e 100644
--- a/crates/oxc_linter/src/snapshots/namespace.snap
+++ b/crates/oxc_linter/src/snapshots/namespace.snap
@@ -8,8 +8,7 @@ expression: namespace
    ·                                                             ─
    ╰────
 
-  ⚠ eslint-plugin-import(namespace): Unable to validate computed reference to imported namespace "names"
-  │     .
+  ⚠ eslint-plugin-import(namespace): Unable to validate computed reference to imported namespace "names".
    ╭─[index.js:1:55]
  1 │ import * as names from './named-exports'; console.log(names['a']);
    ·                                                       ──────────
diff --git a/crates/oxc_linter/src/snapshots/no_setter_return.snap b/crates/oxc_linter/src/snapshots/no_setter_return.snap
index b2315064cbf8..d02cc54f6865 100644
--- a/crates/oxc_linter/src/snapshots/no_setter_return.snap
+++ b/crates/oxc_linter/src/snapshots/no_setter_return.snap
@@ -2,253 +2,253 @@
 source: crates/oxc_linter/src/tester.rs
 expression: no_setter_return
 ---
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:16]
  1 │ ({ set a(val){ return val + 1; } })
    ·                ───────────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:17]
  1 │ ({ set a(val) { return 1; } })
    ·                 ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:24]
  1 │ class A { set a(val) { return 1; } }
    ·                        ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:31]
  1 │ class A { static set a(val) { return 1; } }
    ·                               ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:23]
  1 │ (class { set a(val) { return 1; } })
    ·                       ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:17]
  1 │ ({ set a(val) { return val; } })
    ·                 ───────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:24]
  1 │ class A { set a(val) { return undefined; } }
    ·                        ─────────────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:23]
  1 │ (class { set a(val) { return null; } })
    ·                       ────────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:17]
  1 │ ({ set a(val) { return x + y; } })
    ·                 ─────────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:24]
  1 │ class A { set a(val) { return foo(); } }
    ·                        ─────────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:23]
  1 │ (class { set a(val) { return this._a; } })
    ·                       ───────────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:17]
  1 │ ({ set a(val) { return this.a; } })
    ·                 ──────────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:28]
  1 │ ({ set a(val) { if (foo) { return 1; }; } })
    ·                            ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:30]
  1 │ class A { set a(val) { try { return 1; } catch(e) {} } }
    ·                              ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:57]
  1 │ (class { set a(val) { while (foo){ if (bar) break; else return 1; } } })
    ·                                                         ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:17]
  1 │ ({ set a(val) { return 1; }, set b(val) { return 1; } })
    ·                 ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:43]
  1 │ ({ set a(val) { return 1; }, set b(val) { return 1; } })
    ·                                           ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:24]
  1 │ class A { set a(val) { return 1; } set b(val) { return 1; } }
    ·                        ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:49]
  1 │ class A { set a(val) { return 1; } set b(val) { return 1; } }
    ·                                                 ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:23]
  1 │ (class { set a(val) { return 1; } static set b(val) { return 1; } })
    ·                       ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:55]
  1 │ (class { set a(val) { return 1; } static set b(val) { return 1; } })
    ·                                                       ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:27]
  1 │ ({ set a(val) { if(val) { return 1; } else { return 2 }; } })
    ·                           ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:46]
  1 │ ({ set a(val) { if(val) { return 1; } else { return 2 }; } })
    ·                                              ────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:46]
  1 │ class A { set a(val) { switch(val) { case 1: return x; case 2: return y; default: return z } } }
    ·                                              ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:64]
  1 │ class A { set a(val) { switch(val) { case 1: return x; case 2: return y; default: return z } } }
    ·                                                                ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:83]
  1 │ class A { set a(val) { switch(val) { case 1: return x; case 2: return y; default: return z } } }
    ·                                                                                   ────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:62]
  1 │ (class { static set a(val) { if (val > 0) { this._val = val; return val; } return false; } })
    ·                                                              ───────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:76]
  1 │ (class { static set a(val) { if (val > 0) { this._val = val; return val; } return false; } })
    ·                                                                            ─────────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:27]
  1 │ ({ set a(val) { if(val) { return 1; } else { return; }; } })
    ·                           ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:46]
  1 │ class A { set a(val) { switch(val) { case 1: return x; case 2: return; default: return z } } }
    ·                                              ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:81]
  1 │ class A { set a(val) { switch(val) { case 1: return x; case 2: return; default: return z } } }
    ·                                                                                 ────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:72]
  1 │ (class { static set a(val) { if (val > 0) { this._val = val; return; } return false; } })
    ·                                                                        ─────────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:32]
  1 │ ({ set a(val) { function b(){} return b(); } })
    ·                                ───────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:24]
  1 │ class A { set a(val) { return () => {}; } }
    ·                        ────────────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:49]
  1 │ (class { set a(val) { function b(){ return 1; } return 2; } })
    ·                                                 ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:41]
  1 │ ({ set a(val) { function b(){ return; } return 1; } })
    ·                                         ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:58]
  1 │ class A { set a(val) { var x = function() { return 1; }; return 2; } }
    ·                                                          ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:50]
  1 │ (class { set a(val) { var x = () => { return; }; return 2; } })
    ·                                                  ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:33]
  1 │ function f(){}; ({ set a(val) { return 1; } });
    ·                                 ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:44]
  1 │ x = function f(){}; class A { set a(val) { return 1; } };
    ·                                            ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:40]
  1 │ x = () => {}; A = class { set a(val) { return 1; } };
    ·                                        ─────────
    ╰────
 
-  × eslint(no-setter-return): Setter cannot return a value
+  ⚠ eslint(no-setter-return): Setter cannot return a value
    ╭─[no_setter_return.tsx:1:25]
  1 │ return; ({ set a(val) { return 1; } }); return 2;
    ·                         ─────────
diff --git a/crates/oxc_linter/src/snapshots/no_useless_promise_resolve_reject.snap b/crates/oxc_linter/src/snapshots/no_useless_promise_resolve_reject.snap
index 4ef5d03cdcfd..df9d1f7092ea 100644
--- a/crates/oxc_linter/src/snapshots/no_useless_promise_resolve_reject.snap
+++ b/crates/oxc_linter/src/snapshots/no_useless_promise_resolve_reject.snap
@@ -93,7 +93,7 @@ expression: no_useless_promise_resolve_reject
  2 │             async function foo() {
  3 │                 return Promise.reject(bar);
    ·                        ───────────────────
- 4 │             }   
+ 4 │             }
    ╰────
   help: Wrapping the error in `Promise.reject` is needlessly verbose. All errors thrown in async functions are already wrapped in a `Promise`.
 
diff --git a/crates/oxc_linter/src/tester.rs b/crates/oxc_linter/src/tester.rs
index a46d26343477..d4359c2f75b2 100644
--- a/crates/oxc_linter/src/tester.rs
+++ b/crates/oxc_linter/src/tester.rs
@@ -4,8 +4,7 @@ use std::{
 };
 
 use oxc_allocator::Allocator;
-use oxc_diagnostics::miette::NamedSource;
-use oxc_diagnostics::{DiagnosticService, GraphicalReportHandler, GraphicalTheme};
+use oxc_diagnostics::{DiagnosticService, GraphicalReportHandler, GraphicalTheme, NamedSource};
 use serde::Deserialize;
 use serde_json::Value;
 
diff --git a/crates/oxc_linter/src/utils/jest/parse_jest_fn.rs b/crates/oxc_linter/src/utils/jest/parse_jest_fn.rs
index 1161224a6fef..97bb9be9692d 100644
--- a/crates/oxc_linter/src/utils/jest/parse_jest_fn.rs
+++ b/crates/oxc_linter/src/utils/jest/parse_jest_fn.rs
@@ -218,7 +218,9 @@ fn is_top_most_call_expr<'a, 'b>(node: &'b AstNode<'a>, ctx: &'b LintContext<'a>
     let mut node = node;
 
     loop {
-        let Some(parent) = ctx.nodes().parent_node(node.id()) else { return true };
+        let Some(parent) = ctx.nodes().parent_node(node.id()) else {
+            return true;
+        };
 
         match parent.kind() {
             AstKind::CallExpression(_) => return false,
diff --git a/crates/oxc_linter/src/utils/nextjs.rs b/crates/oxc_linter/src/utils/nextjs.rs
index 94fcd00dbb87..69898c32c0b4 100644
--- a/crates/oxc_linter/src/utils/nextjs.rs
+++ b/crates/oxc_linter/src/utils/nextjs.rs
@@ -7,7 +7,9 @@ pub fn is_in_app_dir(file_path: &str) -> bool {
 }
 
 pub fn is_document_page(file_path: &str) -> bool {
-    let Some(page) = file_path.split("pages").last() else { return false };
+    let Some(page) = file_path.split("pages").last() else {
+        return false;
+    };
     page.starts_with("/_document") || page.starts_with("\\_document")
 }
 
diff --git a/crates/oxc_linter/src/utils/react.rs b/crates/oxc_linter/src/utils/react.rs
index a553bafbdb8f..df31a4bb4a00 100644
--- a/crates/oxc_linter/src/utils/react.rs
+++ b/crates/oxc_linter/src/utils/react.rs
@@ -28,7 +28,9 @@ pub fn has_jsx_prop<'a, 'b>(
     node.attributes.iter().find(|attr| match attr {
         JSXAttributeItem::SpreadAttribute(_) => false,
         JSXAttributeItem::Attribute(attr) => {
-            let JSXAttributeName::Identifier(name) = &attr.name else { return false };
+            let JSXAttributeName::Identifier(name) = &attr.name else {
+                return false;
+            };
 
             name.name.as_str() == target_prop
         }
@@ -42,7 +44,9 @@ pub fn has_jsx_prop_lowercase<'a, 'b>(
     node.attributes.iter().find(|attr| match attr {
         JSXAttributeItem::SpreadAttribute(_) => false,
         JSXAttributeItem::Attribute(attr) => {
-            let JSXAttributeName::Identifier(name) = &attr.name else { return false };
+            let JSXAttributeName::Identifier(name) = &attr.name else {
+                return false;
+            };
 
             name.name.as_str().to_lowercase() == target_prop.to_lowercase()
         }
@@ -164,7 +168,9 @@ const PRAGMA: &str = "React";
 const CREATE_CLASS: &str = "createReactClass";
 
 pub fn is_es5_component(node: &AstNode) -> bool {
-    let AstKind::CallExpression(call_expr) = node.kind() else { return false };
+    let AstKind::CallExpression(call_expr) = node.kind() else {
+        return false;
+    };
 
     if let Some(member_expr) = call_expr.callee.as_member_expression() {
         if let Expression::Identifier(ident) = member_expr.object() {
@@ -184,7 +190,9 @@ const COMPONENT: &str = "Component";
 const PURE_COMPONENT: &str = "PureComponent";
 
 pub fn is_es6_component(node: &AstNode) -> bool {
-    let AstKind::Class(class_expr) = node.kind() else { return false };
+    let AstKind::Class(class_expr) = node.kind() else {
+        return false;
+    };
     if let Some(super_class) = &class_expr.super_class {
         if let Some(member_expr) = super_class.as_member_expression() {
             if let Expression::Identifier(ident) = member_expr.object() {
diff --git a/crates/oxc_linter/src/utils/unicorn/boolean.rs b/crates/oxc_linter/src/utils/unicorn/boolean.rs
index 2bba43022330..1892ccf869be 100644
--- a/crates/oxc_linter/src/utils/unicorn/boolean.rs
+++ b/crates/oxc_linter/src/utils/unicorn/boolean.rs
@@ -13,7 +13,9 @@ pub fn is_logic_not(node: &AstKind) -> bool {
     matches!(node, AstKind::UnaryExpression(unary_expr) if unary_expr.operator == UnaryOperator::LogicalNot)
 }
 fn is_logic_not_argument<'a, 'b>(node: &'b AstNode<'a>, ctx: &'b LintContext<'a>) -> bool {
-    let Some(parent) = outermost_paren_parent(node, ctx) else { return false };
+    let Some(parent) = outermost_paren_parent(node, ctx) else {
+        return false;
+    };
     is_logic_not(&parent.kind())
 }
 pub fn is_boolean_call(kind: &AstKind) -> bool {
@@ -44,7 +46,9 @@ pub fn is_boolean_node<'a, 'b>(node: &'b AstNode<'a>, ctx: &'b LintContext<'a>)
         return true;
     }
 
-    let Some(parent) = outermost_paren_parent(node, ctx) else { return false };
+    let Some(parent) = outermost_paren_parent(node, ctx) else {
+        return false;
+    };
 
     if matches!(
         parent.kind(),