+ "oorandom",

+ Lint {

+ label: "ambiguous_wide_pointer_comparisons",

+ description: r##"detects ambiguous wide pointer comparisons"##,

+ },

+ description: r##"lint group for: deref-into-dyn-supertrait, ambiguous-associated-items, ambiguous-glob-imports, byte-slice-in-packed-struct-with-derive, cenum-impl-drop-cast, coherence-leak-check, conflicting-repr-hints, const-evaluatable-unchecked, deprecated-cfg-attr-crate-type-name, elided-lifetimes-in-associated-constant, forbidden-lint-groups, ill-formed-attribute-input, indirect-structural-match, invalid-doc-attributes, invalid-type-param-default, late-bound-lifetime-arguments, legacy-derive-helpers, macro-expanded-macro-exports-accessed-by-absolute-paths, missing-fragment-specifier, order-dependent-trait-objects, patterns-in-fns-without-body, pointer-structural-match, proc-macro-back-compat, proc-macro-derive-resolution-fallback, pub-use-of-private-extern-crate, repr-transparent-external-private-fields, semicolon-in-expressions-from-macros, soft-unstable, uninhabited-static, unstable-name-collisions, unstable-syntax-pre-expansion, unsupported-calling-conventions, where-clauses-object-safety, writes-through-immutable-pointer"##,

+ Lint { label: "non_local_definitions", description: r##"checks for non-local definitions"## },

+ label: "rust_2024_compatibility",

+ description: r##"lint group for: static-mut-refs, unsafe-op-in-unsafe-fn"##,

+ },

+ Lint {

+ label: "static_mut_refs",

+ description: r##"shared references or mutable references of mutable static is discouraged"##,

+ label: "unit_bindings",

+ description: r##"binding is useless because it has the unit `()` type"##,

+ },

+ Lint {

+ Lint { label: "unstable_features", description: r##"enabling unstable features"## },

+ Lint {

+ label: "writes_through_immutable_pointer",

+ description: r##"shared references are immutable, and pointers derived from them must not be written to"##,

+ },

+ description: r##"lint group for: deref-into-dyn-supertrait, ambiguous-associated-items, ambiguous-glob-imports, byte-slice-in-packed-struct-with-derive, cenum-impl-drop-cast, coherence-leak-check, conflicting-repr-hints, const-evaluatable-unchecked, deprecated-cfg-attr-crate-type-name, elided-lifetimes-in-associated-constant, forbidden-lint-groups, ill-formed-attribute-input, indirect-structural-match, invalid-doc-attributes, invalid-type-param-default, late-bound-lifetime-arguments, legacy-derive-helpers, macro-expanded-macro-exports-accessed-by-absolute-paths, missing-fragment-specifier, order-dependent-trait-objects, patterns-in-fns-without-body, pointer-structural-match, proc-macro-back-compat, proc-macro-derive-resolution-fallback, pub-use-of-private-extern-crate, repr-transparent-external-private-fields, semicolon-in-expressions-from-macros, soft-unstable, uninhabited-static, unstable-name-collisions, unstable-syntax-pre-expansion, unsupported-calling-conventions, where-clauses-object-safety, writes-through-immutable-pointer"##,

+ "writes_through_immutable_pointer",

+ label: "rust_2024_compatibility",

+ description: r##"lint group for: static-mut-refs, unsafe-op-in-unsafe-fn"##,

+ },

+ children: &["static_mut_refs", "unsafe_op_in_unsafe_fn"],

+ },

+ LintGroup {

+ lint: Lint {

+See Also: [`fn_traits`](../library-features/fn-traits.md)

+----

+

+The `async_fn_traits` feature allows for implementation of the [`AsyncFn*`] traits

+for creating custom closure-like types that return futures.

+

+[`AsyncFn*`]: ../../std/ops/trait.AsyncFn.html

+

+The main difference to the `Fn*` family of traits is that `AsyncFn` can return a future

+that borrows from itself (`FnOnce::Output` has no lifetime parameters, while `AsyncFn::CallFuture` does).

+ label: "const_intrinsic_copy",

+ description: r##"# `const_intrinsic_copy`

+

+The tracking issue for this feature is: [#80697]

+

+[#80697]: https://github.com/rust-lang/rust/issues/80697

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "const_ops",

+ description: r##"# `const_ops`

+

+The tracking issue for this feature is: [#90080]

+

+[#90080]: https://github.com/rust-lang/rust/issues/90080

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "const_refs_to_static",

+ description: r##"# `const_refs_to_static`

+

+The tracking issue for this feature is: [#119618]

+

+[#119618]: https://github.com/rust-lang/rust/issues/119618

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "delayed_debug_assertions",

+ description: r##"# `delayed_debug_assertions`

+

+This feature has no tracking issue, and is therefore likely internal to the compiler, not being intended for general use.

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "duration_constructors",

+ description: r##"# `duration_constructors`

+

+The tracking issue for this feature is: [#120301]

+

+[#120301]: https://github.com/rust-lang/rust/issues/120301

+

+------------------------

+

+Add the methods `from_mins`, `from_hours` and `from_days` to `Duration`.

+"##,

+ },

+ Lint {

+ label: "duration_units",

+ description: r##"# `duration_units`

+

+The tracking issue for this feature is: [#120301]

+

+[#120301]: https://github.com/rust-lang/rust/issues/120301

+

+------------------------

+"##,

+ },

+ Lint {

+Intrinsics are rarely intended to be stable directly, but are usually

+## Intrinsics with fallback logic

+

+Many intrinsics can be written in pure rust, albeit inefficiently or without supporting

+some features that only exist on some backends. Backends can simply not implement those

+intrinsics without causing any code miscompilations or failures to compile.

+All intrinsic fallback bodies are automatically made cross-crate inlineable (like `#[inline]`)

+by the codegen backend, but not the MIR inliner.

+

+```rust

+#![feature(rustc_attrs, effects)]

+#![allow(internal_features)]

+

+#[rustc_intrinsic]

+const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize) {}

+```

+

+Since these are just regular functions, it is perfectly ok to create the intrinsic twice:

+

+```rust

+#![feature(rustc_attrs, effects)]

+#![allow(internal_features)]

+

+#[rustc_intrinsic]

+const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize) {}

+

+mod foo {

+ #[rustc_intrinsic]

+ const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize) {

+ panic!("noisy const dealloc")

+ }

+}

+

+```

+

+The behaviour on backends that override the intrinsic is exactly the same. On other

+backends, the intrinsic behaviour depends on which implementation is called, just like

+with any regular function.

+

+## Intrinsics lowered to MIR instructions

+

+Various intrinsics have native MIR operations that they correspond to. Instead of requiring

+backends to implement both the intrinsic and the MIR operation, the `lower_intrinsics` pass

+will convert the calls to the MIR operation. Backends do not need to know about these intrinsics

+at all.

+

+## Intrinsics without fallback logic

+

+These must be implemented by all backends.

+

+As with any other FFI functions, these are by default always `unsafe` to call.

+You can add `#[rustc_safe_intrinsic]` to the intrinsic to make it safe to call.

+ label: "is_riscv_feature_detected",

+ description: r##"# `is_riscv_feature_detected`

+

+The tracking issue for this feature is: [#111192]

+

+[#111192]: https://github.com/rust-lang/rust/issues/111192

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "lahfsahf_target_feature",

+ description: r##"# `lahfsahf_target_feature`

+

+The tracking issue for this feature is: [#44839]

+

+[#44839]: https://github.com/rust-lang/rust/issues/44839

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "local_waker",

+ description: r##"# `local_waker`

+

+The tracking issue for this feature is: [#118959]

+

+[#118959]: https://github.com/rust-lang/rust/issues/118959

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "mapped_lock_guards",

+ description: r##"# `mapped_lock_guards`

+

+The tracking issue for this feature is: [#117108]

+

+[#117108]: https://github.com/rust-lang/rust/issues/117108

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "os_str_display",

+ description: r##"# `os_str_display`

+

+The tracking issue for this feature is: [#120048]

+

+[#120048]: https://github.com/rust-lang/rust/issues/120048

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "pattern_complexity",

+ description: r##"# `pattern_complexity`

+

+This feature has no tracking issue, and is therefore likely internal to the compiler, not being intended for general use.

+

+------------------------

+"##,

+ },

+ Lint {

+The tracking issue for this feature is: [#121042]

+

+[#121042]: https://github.com/rust-lang/rust/issues/121042

+ label: "prfchw_target_feature",

+ description: r##"# `prfchw_target_feature`

+

+The tracking issue for this feature is: [#44839]

+

+[#44839]: https://github.com/rust-lang/rust/issues/44839

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "reentrant_lock",

+ description: r##"# `reentrant_lock`

+

+The tracking issue for this feature is: [#121440]

+

+[#121440]: https://github.com/rust-lang/rust/issues/121440

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "stdarch_arm_feature_detection",

+ description: r##"# `stdarch_arm_feature_detection`

+The tracking issue for this feature is: [#111190]

+[#111190]: https://github.com/rust-lang/rust/issues/111190

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "stdarch_mips_feature_detection",

+ description: r##"# `stdarch_mips_feature_detection`

+

+The tracking issue for this feature is: [#111188]

+

+[#111188]: https://github.com/rust-lang/rust/issues/111188

+

+------------------------

+"##,

+ },

+ Lint {

+ label: "stdarch_powerpc_feature_detection",

+ description: r##"# `stdarch_powerpc_feature_detection`

+

+The tracking issue for this feature is: [#111191]

+

+[#111191]: https://github.com/rust-lang/rust/issues/111191

+ label: "stdio_makes_pipe",

+ description: r##"# `stdio_makes_pipe`

+The tracking issue for this feature is: [#98288]

+[#98288]: https://github.com/rust-lang/rust/issues/98288

+ label: "tcp_deferaccept",

+ description: r##"# `tcp_deferaccept`

+

+The tracking issue for this feature is: [#119639]

+

+[#119639]: https://github.com/rust-lang/rust/issues/119639

+

+------------------------

+"##,

+ },

+ Lint {

+ description: r##"Checks for `if` and `match` conditions that use blocks containing an

+ label: "clippy::deprecated_clippy_cfg_attr",

+ description: r##"Checks for `#[cfg_attr(feature = cargo-clippy, ...)]` and for

+`#[cfg(feature = cargo-clippy)]` and suggests to replace it with

+`#[cfg_attr(clippy, ...)]` or `#[cfg(clippy)]`."##,

+ },

+ Lint {

+ Lint { label: "clippy::empty_docs", description: r##"Detects documentation that is empty."## },

+ Lint { label: "clippy::manual_c_str_literals", description: r##""## },

+ label: "clippy::mixed_attributes_style",

+ description: r##"Checks that an item has only one kind of attributes."##,

+ },

+ Lint {

+ label: "clippy::multiple_bound_locations",

+ description: r##"Check if a generic is defined both in the bound predicate and in the `where` clause."##,

+ },

+ Lint {

+into a string, then later attempting to use that string for an operation that will never

+work for strings with a trailing newline character in it (e.g. parsing into a `i32`)."##,

+ label: "clippy::ref_as_ptr",

+ description: r##"Checks for casts of references to pointer using `as`

+and suggests `std::ptr::from_ref` and `std::ptr::from_mut` instead."##,

+ },

+ Lint {

+ label: "clippy::unnecessary_clippy_cfg",

+ description: r##"Checks for `#[cfg_attr(clippy, allow(clippy::lint))]`

+and suggests to replace it with `#[allow(clippy::lint)]`."##,

+ },

+ Lint {

+ label: "clippy::unnecessary_get_then_check",

+ description: r##"Checks the usage of `.get().is_some()` or `.get().is_none()` on std map types."##,

+ },

+ Lint {

+ description: r##"lint group for: clippy::bool_to_int_with_if, clippy::borrow_as_ptr, clippy::case_sensitive_file_extension_comparisons, clippy::cast_lossless, clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::cast_precision_loss, clippy::cast_ptr_alignment, clippy::cast_sign_loss, clippy::checked_conversions, clippy::cloned_instead_of_copied, clippy::copy_iterator, clippy::default_trait_access, clippy::doc_link_with_quotes, clippy::doc_markdown, clippy::empty_enum, clippy::enum_glob_use, clippy::expl_impl_clone_on_copy, clippy::explicit_deref_methods, clippy::explicit_into_iter_loop, clippy::explicit_iter_loop, clippy::filter_map_next, clippy::flat_map_option, clippy::float_cmp, clippy::fn_params_excessive_bools, clippy::from_iter_instead_of_collect, clippy::if_not_else, clippy::ignored_unit_patterns, clippy::implicit_clone, clippy::implicit_hasher, clippy::inconsistent_struct_constructor, clippy::index_refutable_slice, clippy::inefficient_to_string, clippy::inline_always, clippy::into_iter_without_iter, clippy::invalid_upcast_comparisons, clippy::items_after_statements, clippy::iter_filter_is_ok, clippy::iter_filter_is_some, clippy::iter_not_returning_iterator, clippy::iter_without_into_iter, clippy::large_digit_groups, clippy::large_futures, clippy::large_stack_arrays, clippy::large_types_passed_by_value, clippy::linkedlist, clippy::macro_use_imports, clippy::manual_assert, clippy::manual_c_str_literals, clippy::manual_instant_elapsed, clippy::manual_is_variant_and, clippy::manual_let_else, clippy::manual_ok_or, clippy::manual_string_new, clippy::many_single_char_names, clippy::map_unwrap_or, clippy::match_bool, clippy::match_on_vec_items, clippy::match_same_arms, clippy::match_wild_err_arm, clippy::match_wildcard_for_single_variants, clippy::maybe_infinite_iter, clippy::mismatching_type_param_order, clippy::missing_errors_doc, clippy::missing_fields_in_debug, clippy::missing_panics_doc, clippy::module_name_repetitions, clippy::must_use_candidate, clippy::mut_mut, clippy::naive_bytecount, clippy::needless_bitwise_bool, clippy::needless_continue, clippy::needless_for_each, clippy::needless_pass_by_value, clippy::needless_raw_string_hashes, clippy::no_effect_underscore_binding, clippy::no_mangle_with_rust_abi, clippy::option_as_ref_cloned, clippy::option_option, clippy::ptr_as_ptr, clippy::ptr_cast_constness, clippy::pub_underscore_fields, clippy::range_minus_one, clippy::range_plus_one, clippy::redundant_closure_for_method_calls, clippy::redundant_else, clippy::ref_as_ptr, clippy::ref_binding_to_reference, clippy::ref_option_ref, clippy::return_self_not_must_use, clippy::same_functions_in_if_condition, clippy::semicolon_if_nothing_returned, clippy::should_panic_without_expect, clippy::similar_names, clippy::single_match_else, clippy::stable_sort_primitive, clippy::str_split_at_newline, clippy::string_add_assign, clippy::struct_excessive_bools, clippy::struct_field_names, clippy::too_many_lines, clippy::transmute_ptr_to_ptr, clippy::trivially_copy_pass_by_ref, clippy::unchecked_duration_subtraction, clippy::unicode_not_nfc, clippy::uninlined_format_args, clippy::unnecessary_box_returns, clippy::unnecessary_join, clippy::unnecessary_wraps, clippy::unnested_or_patterns, clippy::unreadable_literal, clippy::unsafe_derive_deserialize, clippy::unused_async, clippy::unused_self, clippy::used_underscore_binding, clippy::verbose_bit_mask, clippy::wildcard_imports, clippy::zero_sized_map_values"##,

+ "clippy::manual_c_str_literals",

+ "clippy::ref_as_ptr",

+ description: r##"lint group for: clippy::almost_complete_range, clippy::arc_with_non_send_sync, clippy::await_holding_invalid_type, clippy::await_holding_lock, clippy::await_holding_refcell_ref, clippy::blanket_clippy_restriction_lints, clippy::cast_abs_to_unsigned, clippy::cast_enum_constructor, clippy::cast_enum_truncation, clippy::cast_nan_to_int, clippy::cast_slice_from_raw_parts, clippy::crate_in_macro_def, clippy::deprecated_clippy_cfg_attr, clippy::drop_non_drop, clippy::duplicate_mod, clippy::empty_docs, clippy::empty_loop, clippy::float_equality_without_abs, clippy::forget_non_drop, clippy::four_forward_slashes, clippy::from_raw_with_void_ptr, clippy::incompatible_msrv, clippy::ineffective_open_options, clippy::iter_out_of_bounds, clippy::join_absolute_paths, clippy::let_underscore_future, clippy::lines_filter_map_ok, clippy::maybe_misused_cfg, clippy::misnamed_getters, clippy::misrefactored_assign_op, clippy::mixed_attributes_style, clippy::multi_assignments, clippy::multiple_bound_locations, clippy::mut_range_bound, clippy::mutable_key_type, clippy::no_effect_replace, clippy::non_canonical_clone_impl, clippy::non_canonical_partial_ord_impl, clippy::octal_escapes, clippy::path_ends_with_ext, clippy::permissions_set_readonly_false, clippy::print_in_format_impl, clippy::rc_clone_in_vec_init, clippy::repeat_vec_with_capacity, clippy::single_range_in_vec_init, clippy::size_of_ref, clippy::suspicious_arithmetic_impl, clippy::suspicious_assignment_formatting, clippy::suspicious_command_arg_space, clippy::suspicious_doc_comments, clippy::suspicious_else_formatting, clippy::suspicious_map, clippy::suspicious_op_assign_impl, clippy::suspicious_open_options, clippy::suspicious_to_owned, clippy::suspicious_unary_op_formatting, clippy::swap_ptr_to_ref, clippy::test_attr_in_doctest, clippy::type_id_on_box, clippy::unconditional_recursion, clippy::unnecessary_clippy_cfg, clippy::unnecessary_get_then_check, clippy::unnecessary_result_map_or_else"##,

+ "clippy::deprecated_clippy_cfg_attr",

+ "clippy::empty_docs",

+ "clippy::mixed_attributes_style",

+ "clippy::multiple_bound_locations",

+ "clippy::unnecessary_clippy_cfg",

+ "clippy::unnecessary_get_then_check",

+ Intrinsics are rarely intended to be stable directly, but are usually

+ ## Intrinsics with fallback logic

+

+ Many intrinsics can be written in pure rust, albeit inefficiently or without supporting

+ some features that only exist on some backends. Backends can simply not implement those

+ intrinsics without causing any code miscompilations or failures to compile.

+ All intrinsic fallback bodies are automatically made cross-crate inlineable (like `#[inline]`)

+ by the codegen backend, but not the MIR inliner.

+

+ ```rust

+ #![feature(rustc_attrs, effects)]

+ #![allow(internal_features)]

+

+ #[rustc_intrinsic]

+ const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize) {}

+ ```

+

+ Since these are just regular functions, it is perfectly ok to create the intrinsic twice:

+

+ ```rust

+ #![feature(rustc_attrs, effects)]

+ #![allow(internal_features)]

+

+ #[rustc_intrinsic]

+ const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize) {}

+

+ mod foo {

+ #[rustc_intrinsic]

+ const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize) {

+ panic!("noisy const dealloc")

+ }

+ }

+

+ ```

+

+ The behaviour on backends that override the intrinsic is exactly the same. On other

+ backends, the intrinsic behaviour depends on which implementation is called, just like

+ with any regular function.

+

+ ## Intrinsics lowered to MIR instructions

+

+ Various intrinsics have native MIR operations that they correspond to. Instead of requiring

+ backends to implement both the intrinsic and the MIR operation, the `lower_intrinsics` pass

+ will convert the calls to the MIR operation. Backends do not need to know about these intrinsics

+ at all.

+

+ ## Intrinsics without fallback logic

+

+ These must be implemented by all backends.

+

+ As with any other FFI functions, these are by default always `unsafe` to call.

+ You can add `#[rustc_safe_intrinsic]` to the intrinsic to make it safe to call.

+[dev-dependencies]

+oorandom = "11.1.3"

+

+workspace = true

+

+#[test]

+fn test_every_chars() {

+ let text: String = {

+ let mut chars: Vec<char> = ((0 as char)..char::MAX).collect(); // Neat!

+ chars.extend("\n".repeat(chars.len() / 16).chars());

+ let seed = std::hash::Hasher::finish(&std::hash::BuildHasher::build_hasher(

+ #[allow(clippy::disallowed_types)]

+ &std::collections::hash_map::RandomState::new(),

+ ));

+ let mut rng = oorandom::Rand32::new(seed);

+ let mut rand_index = |i| rng.rand_range(0..i as u32) as usize;

+ let mut remaining = chars.len() - 1;

+ while remaining > 0 {

+ let index = rand_index(remaining);

+ chars.swap(remaining, index);

+ remaining -= 1;

+ }

+ chars.into_iter().collect()

+ };

+ assert!(text.contains('💩')); // Sanity check.

+

+ let line_index = LineIndex::new(&text);

+

+ let mut lin_col = LineCol { line: 0, col: 0 };

+ let mut col_utf16 = 0;

+ let mut col_utf32 = 0;

+ for (offset, c) in text.char_indices() {

+ let got_offset = line_index.offset(lin_col).unwrap();

+ assert_eq!(usize::from(got_offset), offset);

+

+ let got_lin_col = line_index.line_col(got_offset);

+ assert_eq!(got_lin_col, lin_col);

+

+ for (enc, col) in [(WideEncoding::Utf16, col_utf16), (WideEncoding::Utf32, col_utf32)] {

+ let wide_lin_col = line_index.to_wide(enc, lin_col).unwrap();

+ let got_lin_col = line_index.to_utf8(enc, wide_lin_col).unwrap();

+ assert_eq!(got_lin_col, lin_col);

+ assert_eq!(wide_lin_col.col, col)

+ }

+

+ if c == '\n' {

+ lin_col.line += 1;

+ lin_col.col = 0;

+ col_utf16 = 0;

+ col_utf32 = 0;

+ } else {

+ lin_col.col += c.len_utf8() as u32;

+ col_utf16 += c.len_utf16() as u32;

+ col_utf32 += 1;

+ }

+ }

+}

+pub(crate) mod diagnostics_docs;

+mod lints;

+ diagnostics_docs::generate(self.check);

+ // lints::generate(self.check) Updating clones the rust repo, so don't run it unless

+ // explicitly asked for

+ flags::CodegenType::DiagnosticsDocs => diagnostics_docs::generate(self.check),

+ flags::CodegenType::LintDefinitions => lints::generate(self.check),

+use crate::{

+ codegen::{add_preamble, list_rust_files, CommentBlock, Location},

+ project_root,

+};

+pub(crate) fn generate(check: bool) {

+ if !check {

+ let contents =

+ diagnostics.into_iter().map(|it| it.to_string()).collect::<Vec<_>>().join("\n\n");

+ let contents = add_preamble("sourcegen_diagnostic_docs", contents);

+ let dst = project_root().join("docs/user/generated_diagnostic.adoc");

+ fs::write(dst, contents).unwrap();

+ }

+ location: Location,

+ for path in list_rust_files(&handlers_dir) {

+ let comment_blocks = CommentBlock::extract("Diagnostic", &text);

+ let location = Location { file: path.clone(), line: block.line };

+use crate::{

+ codegen::{add_preamble, ensure_file_contents, list_files, reformat},

+ project_root,

+};

+

+/// This clones rustc repo, and so is not worth to keep up-to-date on a constant basis.

+pub(crate) fn generate(check: bool) {

+ let contents = add_preamble("sourcegen_lints", reformat(contents));

+ ensure_file_contents(destination.as_path(), &contents, check);

+ let mut lints = lints.chain(lint_groups).collect::<Vec<_>>();

+ lints.sort_by(|(ident, ..), (ident2, ..)| ident.cmp(ident2));

+

+ let mut lints_rustdoc = lints_rustdoc.chain(lint_groups_rustdoc).collect::<Vec<_>>();

+ lints_rustdoc.sort_by(|(ident, ..), (ident2, ..)| ident.cmp(ident2));

+ .flat_map(|it| list_files(&src_dir.join(it)))

+ let description = format!("lint group for: {}", children.join(", "));

+ let children = format!(

+ "&[{}]",

+ children.iter().map(|it| format!("\"{it}\"")).collect::<Vec<_>>().join(", ")

+ );

+ DiagnosticsDocs,

+ LintDefinitions,

+ "diagnostics-docs" => Ok(Self::DiagnosticsDocs),

+ "lints-definitions" => Ok(Self::LintDefinitions),

+ codegen::diagnostics_docs::generate(false);