Subject: Re: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost all color

From: Eval Exec <[email-masked]>
Date: Sun, 20 Apr 2025 15:19:20 +0800

Oh! In the reproduce step, I write a typo, the bug can be reproduced by 
setting different `treesit-font-lock-level`, wen 
`treesit-font-lock-level` is 3, all colors are good, when 
treesit-font-lock-level is 4, all colors are lost.
To reproduce this: use this rust file:

Then eval:
1. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
all color are lost.

2. (progn  (setq treesit-font-lock-level 3) (revert-buffer))
colors are good. !Important, level 3 is good, but level 4 lost colors.

3. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
all color are lost again.

Can you reproduce this?

On 4/20/25 06:12, Vincenzo Pupillo wrote:
> If the attached file is correct, it appears to be a grammar bug (the tree-
> sitter-rust grammar). Take a look at the attached screenshot (libtree-
> sitter-0.25.2 and tree-sitter-rust v0.24.0)
> 
> Vincenzo
> 
> In data sabato 19 aprile 2025 07:10:57 Ora legale dell’Europa centrale, Eval
> Exec ha scritto:
>> Hello,
>> I'm visiting a rust file, when I set treesit-font-lock-level to 3, all
>> color are good, when I set treesit-font-lock-level to 4, all color as
>> lost.
>> To reproduce this: use this rust file:
>>
>> Then eval:
>> 1. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
>> all color are lost.
>>
>> 2. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
>> colors are good.
>>
>> 3. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
>> all color are lost again.
>>
>>
>> ```rust
>>
>> //! Primitive traits and types representing basic properties of types.
>> //!
>> //! Rust types can be classified in various useful ways according to
>> //! their intrinsic properties. These classifications are represented
>> //! as traits.
>>
>> #![stable(feature = "rust1", since = "1.0.0")]
>>
>> use crate::cell::UnsafeCell;
>> use crate::cmp;
>> use crate::fmt::Debug;
>> use crate::hash::{Hash, Hasher};
>>
>> /// Implements a given marker trait for multiple types at the same time.
>> ///
>> /// The basic syntax looks like this:
>> /// ```ignore private macro
>> /// marker_impls! { MarkerTrait for u8, i8 }
>> /// ```
>> /// You can also implement `unsafe` traits
>> /// ```ignore private macro
>> /// marker_impls! { unsafe MarkerTrait for u8, i8 }
>> /// ```
>> /// Add attributes to all impls:
>> /// ```ignore private macro
>> /// marker_impls! {
>> ///     #[allow(lint)]
>> ///     #[unstable(feature = "marker_trait", issue = "none")]
>> ///     MarkerTrait for u8, i8
>> /// }
>> /// ```
>> /// And use generics:
>> /// ```ignore private macro
>> /// marker_impls! {
>> ///     MarkerTrait for
>> ///         u8, i8,
>> ///         {T: ?Sized} *const T,
>> ///         {T: ?Sized} *mut T,
>> ///         {T: MarkerTrait} PhantomData<T>,
>> ///         u32,
>> /// }
>> /// ```
>> #[unstable(feature = "internal_impls_macro", issue = "none")]
>> // Allow implementations of `UnsizedConstParamTy` even though std cannot use
>> that feature. #[allow_internal_unstable(unsized_const_params)]
>> macro marker_impls {
>>      ( $(#[$($meta:tt)*])* $Trait:ident for $({$($bounds:tt)*})? $T:ty $(,
>> $($rest:tt)*)? ) => { $(#[$($meta)*])* impl< $($($bounds)*)? > $Trait for
>> $T {}
>>          marker_impls! { $(#[$($meta)*])* $Trait for $($($rest)*)? }
>>      },
>>      ( $(#[$($meta:tt)*])* $Trait:ident for ) => {},
>>
>>      ( $(#[$($meta:tt)*])* unsafe $Trait:ident for $({$($bounds:tt)*})? $T:ty
>> $(, $($rest:tt)*)? ) => { $(#[$($meta)*])* unsafe impl< $($($bounds)*)? >
>> $Trait for $T {} marker_impls! { $(#[$($meta)*])* unsafe $Trait for
>> $($($rest)*)? } },
>>      ( $(#[$($meta:tt)*])* unsafe $Trait:ident for ) => {},
>> }
>>
>> /// Types that can be transferred across thread boundaries.
>> ///
>> /// This trait is automatically implemented when the compiler determines
>> it's /// appropriate.
>> ///
>> /// An example of a non-`Send` type is the reference-counting pointer
>> /// [`rc::Rc`][`Rc`]. If two threads attempt to clone [`Rc`]s that point to
>> the same /// reference-counted value, they might try to update the
>> reference count at the /// same time, which is [undefined behavior][ub]
>> because [`Rc`] doesn't use atomic /// operations. Its cousin
>> [`sync::Arc`][arc] does use atomic operations (incurring /// some overhead)
>> and thus is `Send`.
>> ///
>> /// See [the Nomicon](../../nomicon/send-and-sync.html) and the [`Sync`]
>> trait for more details. ///
>> /// [`Rc`]: ../../std/rc/struct.Rc.html
>> /// [arc]: ../../std/sync/struct.Arc.html
>> /// [ub]: ../../reference/behavior-considered-undefined.html
>> #[stable(feature = "rust1", since = "1.0.0")]
>> #[cfg_attr(not(test), rustc_diagnostic_item = "Send")]
>> #[diagnostic::on_unimplemented(
>>      message = "`{Self}` cannot be sent between threads safely",
>>      label = "`{Self}` cannot be sent between threads safely"
>> )]
>> pub unsafe auto trait Send {
>>      // empty.
>> }
>>
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> !Send for *const T {}
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> !Send for *mut T {}
>>
>> // Most instances arise automatically, but this instance is needed to link
>> up `T: Sync` with // `&T: Send` (and it also removes the unsound default
>> instance `T Send` -> `&T: Send` that would // otherwise exist).
>> #[stable(feature = "rust1", since = "1.0.0")]
>> unsafe impl<T: Sync + ?Sized> Send for &T {}
>>
>> /// Types with a constant size known at compile time.
>> ///
>> /// All type parameters have an implicit bound of `Sized`. The special
>> syntax /// `?Sized` can be used to remove this bound if it's not
>> appropriate. ///
>> /// ```
>> /// # #![allow(dead_code)]
>> /// struct Foo<T>(T);
>> /// struct Bar<T: ?Sized>(T);
>> ///
>> /// // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for
>> [i32] /// struct BarUse(Bar<[i32]>); // OK
>> /// ```
>> ///
>> /// The one exception is the implicit `Self` type of a trait. A trait does
>> not /// have an implicit `Sized` bound as this is incompatible with [trait
>> object]s /// where, by definition, the trait needs to work with all
>> possible implementors, /// and thus could be any size.
>> ///
>> /// Although Rust will let you bind `Sized` to a trait, you won't
>> /// be able to use it to form a trait object later:
>> ///
>> /// ```
>> /// # #![allow(unused_variables)]
>> /// trait Foo { }
>> /// trait Bar: Sized { }
>> ///
>> /// struct Impl;
>> /// impl Foo for Impl { }
>> /// impl Bar for Impl { }
>> ///
>> /// let x: &dyn Foo = &Impl;    // OK
>> /// // let y: &dyn Bar = &Impl; // error: the trait `Bar` cannot
>> ///                             // be made into an object
>> /// ```
>> ///
>> /// [trait object]: ../../book/ch17-02-trait-objects.html
>> #[doc(alias = "?", alias = "?Sized")]
>> #[stable(feature = "rust1", since = "1.0.0")]
>> #[lang = "sized"]
>> #[diagnostic::on_unimplemented(
>>      message = "the size for values of type `{Self}` cannot be known at
>> compilation time", label = "doesn't have a size known at compile-time"
>> )]
>> #[fundamental] // for Default, for example, which requires that `[T]:
>> !Default` be evaluatable #[rustc_specialization_trait]
>> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =
>> false))] #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
>> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
>> #[rustc_coinductive]
>> pub trait Sized {
>>      // Empty.
>> }
>>
>> /// Types that can be "unsized" to a dynamically-sized type.
>> ///
>> /// For example, the sized array type `[i8; 2]` implements `Unsize<[i8]>`
>> and /// `Unsize<dyn fmt::Debug>`.
>> ///
>> /// All implementations of `Unsize` are provided automatically by the
>> compiler. /// Those implementations are:
>> ///
>> /// - Arrays `[T; N]` implement `Unsize<[T]>`.
>> /// - A type implements `Unsize<dyn Trait + 'a>` if all of these conditions
>> are met: ///   - The type implements `Trait`.
>> ///   - `Trait` is dyn-compatible[^1].
>> ///   - The type is sized.
>> ///   - The type outlives `'a`.
>> /// - Structs `Foo<..., T1, ..., Tn, ...>` implement `Unsize<Foo<..., U1,
>> ..., Un, ...>>` /// where any number of (type and const) parameters may be
>> changed if all of these conditions /// are met:
>> ///   - Only the last field of `Foo` has a type involving the parameters
>> `T1`, ..., `Tn`. ///   - All other parameters of the struct are equal.
>> ///   - `Field<T1, ..., Tn>: Unsize<Field<U1, ..., Un>>`, where `Field<...>`
>> stands for the actual ///     type of the struct's last field.
>> ///
>> /// `Unsize` is used along with [`ops::CoerceUnsized`] to allow
>> /// "user-defined" containers such as [`Rc`] to contain dynamically-sized
>> /// types. See the [DST coercion RFC][RFC982] and [the nomicon entry on
>> coercion][nomicon-coerce] /// for more details.
>> ///
>> /// [`ops::CoerceUnsized`]: crate::ops::CoerceUnsized
>> /// [`Rc`]: ../../std/rc/struct.Rc.html
>> /// [RFC982]:
>> https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md ///
>> [nomicon-coerce]: ../../nomicon/coercions.html
>> /// [^1]: Formerly known as *object safe*.
>> #[unstable(feature = "unsize", issue = "18598")]
>> #[lang = "unsize"]
>> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =
>> false))] #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
>> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
>> pub trait Unsize<T: ?Sized> {
>>      // Empty.
>> }
>>
>> /// Required trait for constants used in pattern matches.
>> ///
>> /// Any type that derives `PartialEq` automatically implements this trait,
>> /// *regardless* of whether its type-parameters implement `PartialEq`.
>> ///
>> /// If a `const` item contains some type that does not implement this trait,
>> /// then that type either (1.) does not implement `PartialEq` (which means
>> the /// constant will not provide that comparison method, which code
>> generation /// assumes is available), or (2.) it implements *its own*
>> version of /// `PartialEq` (which we assume does not conform to a
>> structural-equality /// comparison).
>> ///
>> /// In either of the two scenarios above, we reject usage of such a constant
>> in /// a pattern match.
>> ///
>> /// See also the [structural match RFC][RFC1445], and [issue 63438] which
>> /// motivated migrating from an attribute-based design to this trait.
>> ///
>> /// [RFC1445]:
>> https://github.com/rust-lang/rfcs/blob/master/text/1445-restrict-constants-> in-patterns.md /// [issue 63438]:
>> https://github.com/rust-lang/rust/issues/63438
>> #[unstable(feature = "structural_match", issue = "31434")]
>> #[diagnostic::on_unimplemented(message = "the type `{Self}` does not
>> `#[derive(PartialEq)]`")] #[lang = "structural_peq"]
>> pub trait StructuralPartialEq {
>>      // Empty.
>> }
>>
>> marker_impls! {
>>      #[unstable(feature = "structural_match", issue = "31434")]
>>      StructuralPartialEq for
>>          usize, u8, u16, u32, u64, u128,
>>          isize, i8, i16, i32, i64, i128,
>>          bool,
>>          char,
>>          str /* Technically requires `[u8]: StructuralPartialEq` */,
>>          (),
>>          {T, const N: usize} [T; N],
>>          {T} [T],
>>          {T: ?Sized} &T,
>> }
>>
>> /// Types whose values can be duplicated simply by copying bits.
>> ///
>> /// By default, variable bindings have 'move semantics.' In other
>> /// words:
>> ///
>> /// ```
>> /// #[derive(Debug)]
>> /// struct Foo;
>> ///
>> /// let x = Foo;
>> ///
>> /// let y = x;
>> ///
>> /// // `x` has moved into `y`, and so cannot be used
>> ///
>> /// // println!("{x:?}"); // error: use of moved value
>> /// ```
>> ///
>> /// However, if a type implements `Copy`, it instead has 'copy semantics':
>> ///
>> /// ```
>> /// // We can derive a `Copy` implementation. `Clone` is also required, as
>> it's /// // a supertrait of `Copy`.
>> /// #[derive(Debug, Copy, Clone)]
>> /// struct Foo;
>> ///
>> /// let x = Foo;
>> ///
>> /// let y = x;
>> ///
>> /// // `y` is a copy of `x`
>> ///
>> /// println!("{x:?}"); // A-OK!
>> /// ```
>> ///
>> /// It's important to note that in these two examples, the only difference
>> is whether you /// are allowed to access `x` after the assignment. Under
>> the hood, both a copy and a move /// can result in bits being copied in
>> memory, although this is sometimes optimized away. ///
>> /// ## How can I implement `Copy`?
>> ///
>> /// There are two ways to implement `Copy` on your type. The simplest is to
>> use `derive`: ///
>> /// ```
>> /// #[derive(Copy, Clone)]
>> /// struct MyStruct;
>> /// ```
>> ///
>> /// You can also implement `Copy` and `Clone` manually:
>> ///
>> /// ```
>> /// struct MyStruct;
>> ///
>> /// impl Copy for MyStruct { }
>> ///
>> /// impl Clone for MyStruct {
>> ///     fn clone(&self) -> MyStruct {
>> ///         *self
>> ///     }
>> /// }
>> /// ```
>> ///
>> /// There is a small difference between the two. The `derive` strategy will
>> also place a `Copy` /// bound on type parameters:
>> ///
>> /// ```
>> /// #[derive(Clone)]
>> /// struct MyStruct<T>(T);
>> ///
>> /// impl<T: Copy> Copy for MyStruct<T> { }
>> /// ```
>> ///
>> /// This isn't always desired. For example, shared references (`&T`) can be
>> copied regardless of /// whether `T` is `Copy`. Likewise, a generic struct
>> containing markers such as [`PhantomData`] /// could potentially be
>> duplicated with a bit-wise copy.
>> ///
>> /// ## What's the difference between `Copy` and `Clone`?
>> ///
>> /// Copies happen implicitly, for example as part of an assignment `y = x`.
>> The behavior of /// `Copy` is not overloadable; it is always a simple
>> bit-wise copy. ///
>> /// Cloning is an explicit action, `x.clone()`. The implementation of
>> [`Clone`] can /// provide any type-specific behavior necessary to duplicate
>> values safely. For example, /// the implementation of [`Clone`] for
>> [`String`] needs to copy the pointed-to string /// buffer in the heap. A
>> simple bitwise copy of [`String`] values would merely copy the /// pointer,
>> leading to a double free down the line. For this reason, [`String`] is
>> [`Clone`] /// but not `Copy`.
>> ///
>> /// [`Clone`] is a supertrait of `Copy`, so everything which is `Copy` must
>> also implement /// [`Clone`]. If a type is `Copy` then its [`Clone`]
>> implementation only needs to return `*self` /// (see the example above).
>> ///
>> /// ## When can my type be `Copy`?
>> ///
>> /// A type can implement `Copy` if all of its components implement `Copy`.
>> For example, this /// struct can be `Copy`:
>> ///
>> /// ```
>> /// # #[allow(dead_code)]
>> /// #[derive(Copy, Clone)]
>> /// struct Point {
>> ///    x: i32,
>> ///    y: i32,
>> /// }
>> /// ```
>> ///
>> /// A struct can be `Copy`, and [`i32`] is `Copy`, therefore `Point` is
>> eligible to be `Copy`. /// By contrast, consider
>> ///
>> /// ```
>> /// # #![allow(dead_code)]
>> /// # struct Point;
>> /// struct PointList {
>> ///     points: Vec<Point>,
>> /// }
>> /// ```
>> ///
>> /// The struct `PointList` cannot implement `Copy`, because [`Vec<T>`] is
>> not `Copy`. If we /// attempt to derive a `Copy` implementation, we'll get
>> an error: ///
>> /// ```text
>> /// the trait `Copy` cannot be implemented for this type; field `points`
>> does not implement `Copy` /// ```
>> ///
>> /// Shared references (`&T`) are also `Copy`, so a type can be `Copy`, even
>> when it holds /// shared references of types `T` that are *not* `Copy`.
>> Consider the following struct, /// which can implement `Copy`, because it
>> only holds a *shared reference* to our non-`Copy` /// type `PointList` from
>> above:
>> ///
>> /// ```
>> /// # #![allow(dead_code)]
>> /// # struct PointList;
>> /// #[derive(Copy, Clone)]
>> /// struct PointListWrapper<'a> {
>> ///     point_list_ref: &'a PointList,
>> /// }
>> /// ```
>> ///
>> /// ## When *can't* my type be `Copy`?
>> ///
>> /// Some types can't be copied safely. For example, copying `&mut T` would
>> create an aliased /// mutable reference. Copying [`String`] would duplicate
>> responsibility for managing the /// [`String`]'s buffer, leading to a
>> double free.
>> ///
>> /// Generalizing the latter case, any type implementing [`Drop`] can't be
>> `Copy`, because it's /// managing some resource besides its own
>> [`size_of::<T>`] bytes. ///
>> /// If you try to implement `Copy` on a struct or enum containing non-`Copy`
>> data, you will get /// the error [E0204].
>> ///
>> /// [E0204]: ../../error_codes/E0204.html
>> ///
>> /// ## When *should* my type be `Copy`?
>> ///
>> /// Generally speaking, if your type _can_ implement `Copy`, it should. Keep
>> in mind, though, /// that implementing `Copy` is part of the public API of
>> your type. If the type might become /// non-`Copy` in the future, it could
>> be prudent to omit the `Copy` implementation now, to /// avoid a breaking
>> API change.
>> ///
>> /// ## Additional implementors
>> ///
>> /// In addition to the [implementors listed below][impls],
>> /// the following types also implement `Copy`:
>> ///
>> /// * Function item types (i.e., the distinct types defined for each
>> function) /// * Function pointer types (e.g., `fn() -> i32`)
>> /// * Closure types, if they capture no value from the environment
>> ///   or if all such captured values implement `Copy` themselves.
>> ///   Note that variables captured by shared reference always implement
>> `Copy` ///   (even if the referent doesn't),
>> ///   while variables captured by mutable reference never implement `Copy`.
>> ///
>> /// [`Vec<T>`]: ../../std/vec/struct.Vec.html
>> /// [`String`]: ../../std/string/struct.String.html
>> /// [`size_of::<T>`]: crate::mem::size_of
>> /// [impls]: #implementors
>> #[stable(feature = "rust1", since = "1.0.0")]
>> #[lang = "copy"]
>> // FIXME(matthewjasper) This allows copying a type that doesn't implement
>> // `Copy` because of unsatisfied lifetime bounds (copying `A<'_>` when only
>> // `A<'static>: Copy` and `A<'_>: Clone`).
>> // We have this attribute here for now only because there are quite a few
>> // existing specializations on `Copy` that already exist in the standard
>> // library, and there's no way to safely have this behavior right now.
>> #[rustc_unsafe_specialization_marker]
>> #[rustc_diagnostic_item = "Copy"]
>> pub trait Copy: Clone {
>>      // Empty.
>> }
>>
>> /// Derive macro generating an impl of the trait `Copy`.
>> #[rustc_builtin_macro]
>> #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
>> #[allow_internal_unstable(core_intrinsics, derive_clone_copy)]
>> pub macro Copy($item:item) {
>>      /* compiler built-in */
>> }
>>
>> // Implementations of `Copy` for primitive types.
>> //
>> // Implementations that cannot be described in Rust
>> // are implemented in `traits::SelectionContext::copy_clone_conditions()`
>> // in `rustc_trait_selection`.
>> marker_impls! {
>>      #[stable(feature = "rust1", since = "1.0.0")]
>>      Copy for
>>          usize, u8, u16, u32, u64, u128,
>>          isize, i8, i16, i32, i64, i128,
>>          f16, f32, f64, f128,
>>          bool, char,
>>          {T: ?Sized} *const T,
>>          {T: ?Sized} *mut T,
>>
>> }
>>
>> #[unstable(feature = "never_type", issue = "35121")]
>> impl Copy for ! {}
>>
>> /// Shared references can be copied, but mutable references *cannot*!
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> Copy for &T {}
>>
>> /// Types for which it is safe to share references between threads.
>> ///
>> /// This trait is automatically implemented when the compiler determines
>> /// it's appropriate.
>> ///
>> /// The precise definition is: a type `T` is [`Sync`] if and only if `&T` is
>> /// [`Send`]. In other words, if there is no possibility of
>> /// [undefined behavior][ub] (including data races) when passing
>> /// `&T` references between threads.
>> ///
>> /// As one would expect, primitive types like [`u8`] and [`f64`]
>> /// are all [`Sync`], and so are simple aggregate types containing them,
>> /// like tuples, structs and enums. More examples of basic [`Sync`]
>> /// types include "immutable" types like `&T`, and those with simple
>> /// inherited mutability, such as [`Box<T>`][box], [`Vec<T>`][vec] and
>> /// most other collection types. (Generic parameters need to be [`Sync`]
>> /// for their container to be [`Sync`].)
>> ///
>> /// A somewhat surprising consequence of the definition is that `&mut T`
>> /// is `Sync` (if `T` is `Sync`) even though it seems like that might
>> /// provide unsynchronized mutation. The trick is that a mutable
>> /// reference behind a shared reference (that is, `& &mut T`)
>> /// becomes read-only, as if it were a `& &T`. Hence there is no risk
>> /// of a data race.
>> ///
>> /// A shorter overview of how [`Sync`] and [`Send`] relate to referencing:
>> /// * `&T` is [`Send`] if and only if `T` is [`Sync`]
>> /// * `&mut T` is [`Send`] if and only if `T` is [`Send`]
>> /// * `&T` and `&mut T` are [`Sync`] if and only if `T` is [`Sync`]
>> ///
>> /// Types that are not `Sync` are those that have "interior
>> /// mutability" in a non-thread-safe form, such as [`Cell`][cell]
>> /// and [`RefCell`][refcell]. These types allow for mutation of
>> /// their contents even through an immutable, shared reference. For
>> /// example the `set` method on [`Cell<T>`][cell] takes `&self`, so it
>> requires /// only a shared reference [`&Cell<T>`][cell]. The method
>> performs no /// synchronization, thus [`Cell`][cell] cannot be `Sync`.
>> ///
>> /// Another example of a non-`Sync` type is the reference-counting
>> /// pointer [`Rc`][rc]. Given any reference [`&Rc<T>`][rc], you can clone
>> /// a new [`Rc<T>`][rc], modifying the reference counts in a non-atomic way.
>> ///
>> /// For cases when one does need thread-safe interior mutability,
>> /// Rust provides [atomic data types], as well as explicit locking via
>> /// [`sync::Mutex`][mutex] and [`sync::RwLock`][rwlock]. These types
>> /// ensure that any mutation cannot cause data races, hence the types
>> /// are `Sync`. Likewise, [`sync::Arc`][arc] provides a thread-safe
>> /// analogue of [`Rc`][rc].
>> ///
>> /// Any types with interior mutability must also use the
>> /// [`cell::UnsafeCell`][unsafecell] wrapper around the value(s) which
>> /// can be mutated through a shared reference. Failing to doing this is
>> /// [undefined behavior][ub]. For example, [`transmute`][transmute]-ing
>> /// from `&T` to `&mut T` is invalid.
>> ///
>> /// See [the Nomicon][nomicon-send-and-sync] for more details about `Sync`.
>> ///
>> /// [box]: ../../std/boxed/struct.Box.html
>> /// [vec]: ../../std/vec/struct.Vec.html
>> /// [cell]: crate::cell::Cell
>> /// [refcell]: crate::cell::RefCell
>> /// [rc]: ../../std/rc/struct.Rc.html
>> /// [arc]: ../../std/sync/struct.Arc.html
>> /// [atomic data types]: crate::sync::atomic
>> /// [mutex]: ../../std/sync/struct.Mutex.html
>> /// [rwlock]: ../../std/sync/struct.RwLock.html
>> /// [unsafecell]: crate::cell::UnsafeCell
>> /// [ub]: ../../reference/behavior-considered-undefined.html
>> /// [transmute]: crate::mem::transmute
>> /// [nomicon-send-and-sync]: ../../nomicon/send-and-sync.html
>> #[stable(feature = "rust1", since = "1.0.0")]
>> #[cfg_attr(not(test), rustc_diagnostic_item = "Sync")]
>> #[lang = "sync"]
>> #[rustc_on_unimplemented(
>>      on(
>>          _Self = "core::cell::once::OnceCell<T>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::OnceLock` instead" ),
>>      on(
>>          _Self = "core::cell::Cell<u8>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU8` instead",
>> ),
>>      on(
>>          _Self = "core::cell::Cell<u16>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU16`
>> instead", ),
>>      on(
>>          _Self = "core::cell::Cell<u32>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU32`
>> instead", ),
>>      on(
>>          _Self = "core::cell::Cell<u64>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU64`
>> instead", ),
>>      on(
>>          _Self = "core::cell::Cell<usize>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicUsize`
>> instead", ),
>>      on(
>>          _Self = "core::cell::Cell<i8>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI8` instead",
>> ),
>>      on(
>>          _Self = "core::cell::Cell<i16>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI16`
>> instead", ),
>>      on(
>>          _Self = "core::cell::Cell<i32>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI32`
>> instead", ),
>>      on(
>>          _Self = "core::cell::Cell<i64>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI64`
>> instead", ),
>>      on(
>>          _Self = "core::cell::Cell<isize>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicIsize`
>> instead", ),
>>      on(
>>          _Self = "core::cell::Cell<bool>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicBool`
>> instead", ),
>>      on(
>>          all(
>>              _Self = "core::cell::Cell<T>",
>>              not(_Self = "core::cell::Cell<u8>"),
>>              not(_Self = "core::cell::Cell<u16>"),
>>              not(_Self = "core::cell::Cell<u32>"),
>>              not(_Self = "core::cell::Cell<u64>"),
>>              not(_Self = "core::cell::Cell<usize>"),
>>              not(_Self = "core::cell::Cell<i8>"),
>>              not(_Self = "core::cell::Cell<i16>"),
>>              not(_Self = "core::cell::Cell<i32>"),
>>              not(_Self = "core::cell::Cell<i64>"),
>>              not(_Self = "core::cell::Cell<isize>"),
>>              not(_Self = "core::cell::Cell<bool>")
>>          ),
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock`", ),
>>      on(
>>          _Self = "core::cell::RefCell<T>",
>>          note = "if you want to do aliasing and mutation between multiple
>> threads, use `std::sync::RwLock` instead", ),
>>      message = "`{Self}` cannot be shared between threads safely",
>>      label = "`{Self}` cannot be shared between threads safely"
>> )]
>> pub unsafe auto trait Sync {
>>      // FIXME(estebank): once support to add notes in
>> `rustc_on_unimplemented` // lands in beta, and it has been extended to
>> check whether a closure is // anywhere in the requirement chain, extend it
>> as such (#48534): // ```
>>      // on(
>>      //     closure,
>>      //     note="`{Self}` cannot be shared safely, consider marking the
>> closure `move`" // ),
>>      // ```
>>
>>      // Empty
>> }
>>
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> !Sync for *const T {}
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> !Sync for *mut T {}
>>
>> /// Zero-sized type used to mark things that "act like" they own a `T`.
>> ///
>> /// Adding a `PhantomData<T>` field to your type tells the compiler that
>> your /// type acts as though it stores a value of type `T`, even though it
>> doesn't /// really. This information is used when computing certain safety
>> properties. ///
>> /// For a more in-depth explanation of how to use `PhantomData<T>`, please
>> see /// [the Nomicon](../../nomicon/phantom-data.html).
>> ///
>> /// # A ghastly note 👻👻👻
>> ///
>> /// Though they both have scary names, `PhantomData` and 'phantom types' are
>> /// related, but not identical. A phantom type parameter is simply a type
>> /// parameter which is never used. In Rust, this often causes the compiler
>> to /// complain, and the solution is to add a "dummy" use by way of
>> `PhantomData`. ///
>> /// # Examples
>> ///
>> /// ## Unused lifetime parameters
>> ///
>> /// Perhaps the most common use case for `PhantomData` is a struct that has
>> an /// unused lifetime parameter, typically as part of some unsafe code.
>> For /// example, here is a struct `Slice` that has two pointers of type
>> `*const T`, /// presumably pointing into an array somewhere:
>> ///
>> /// ```compile_fail,E0392
>> /// struct Slice<'a, T> {
>> ///     start: *const T,
>> ///     end: *const T,
>> /// }
>> /// ```
>> ///
>> /// The intention is that the underlying data is only valid for the
>> /// lifetime `'a`, so `Slice` should not outlive `'a`. However, this
>> /// intent is not expressed in the code, since there are no uses of
>> /// the lifetime `'a` and hence it is not clear what data it applies
>> /// to. We can correct this by telling the compiler to act *as if* the
>> /// `Slice` struct contained a reference `&'a T`:
>> ///
>> /// ```
>> /// use std::marker::PhantomData;
>> ///
>> /// # #[allow(dead_code)]
>> /// struct Slice<'a, T> {
>> ///     start: *const T,
>> ///     end: *const T,
>> ///     phantom: PhantomData<&'a T>,
>> /// }
>> /// ```
>> ///
>> /// This also in turn infers the lifetime bound `T: 'a`, indicating
>> /// that any references in `T` are valid over the lifetime `'a`.
>> ///
>> /// When initializing a `Slice` you simply provide the value
>> /// `PhantomData` for the field `phantom`:
>> ///
>> /// ```
>> /// # #![allow(dead_code)]
>> /// # use std::marker::PhantomData;
>> /// # struct Slice<'a, T> {
>> /// #     start: *const T,
>> /// #     end: *const T,
>> /// #     phantom: PhantomData<&'a T>,
>> /// # }
>> /// fn borrow_vec<T>(vec: &Vec<T>) -> Slice<'_, T> {
>> ///     let ptr = vec.as_ptr();
>> ///     Slice {
>> ///         start: ptr,
>> ///         end: unsafe { ptr.add(vec.len()) },
>> ///         phantom: PhantomData,
>> ///     }
>> /// }
>> /// ```
>> ///
>> /// ## Unused type parameters
>> ///
>> /// It sometimes happens that you have unused type parameters which
>> /// indicate what type of data a struct is "tied" to, even though that
>> /// data is not actually found in the struct itself. Here is an
>> /// example where this arises with [FFI]. The foreign interface uses
>> /// handles of type `*mut ()` to refer to Rust values of different
>> /// types. We track the Rust type using a phantom type parameter on
>> /// the struct `ExternalResource` which wraps a handle.
>> ///
>> /// [FFI]:
>> ../../book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external
>> -code ///
>> /// ```
>> /// # #![allow(dead_code)]
>> /// # trait ResType { }
>> /// # struct ParamType;
>> /// # mod foreign_lib {
>> /// #     pub fn new(_: usize) -> *mut () { 42 as *mut () }
>> /// #     pub fn do_stuff(_: *mut (), _: usize) {}
>> /// # }
>> /// # fn convert_params(_: ParamType) -> usize { 42 }
>> /// use std::marker::PhantomData;
>> /// use std::mem;
>> ///
>> /// struct ExternalResource<R> {
>> ///    resource_handle: *mut (),
>> ///    resource_type: PhantomData<R>,
>> /// }
>> ///
>> /// impl<R: ResType> ExternalResource<R> {
>> ///     fn new() -> Self {
>> ///         let size_of_res = mem::size_of::<R>();
>> ///         Self {
>> ///             resource_handle: foreign_lib::new(size_of_res),
>> ///             resource_type: PhantomData,
>> ///         }
>> ///     }
>> ///
>> ///     fn do_stuff(&self, param: ParamType) {
>> ///         let foreign_params = convert_params(param);
>> ///         foreign_lib::do_stuff(self.resource_handle, foreign_params);
>> ///     }
>> /// }
>> /// ```
>> ///
>> /// ## Ownership and the drop check
>> ///
>> /// The exact interaction of `PhantomData` with drop check **may change in
>> the future**. ///
>> /// Currently, adding a field of type `PhantomData<T>` indicates that your
>> type *owns* data of type /// `T` in very rare circumstances. This in turn
>> has effects on the Rust compiler's [drop check] /// analysis. For the exact
>> rules, see the [drop check] documentation. ///
>> /// ## Layout
>> ///
>> /// For all `T`, the following are guaranteed:
>> /// * `size_of::<PhantomData<T>>() == 0`
>> /// * `align_of::<PhantomData<T>>() == 1`
>> ///
>> /// [drop check]: Drop#drop-check
>> #[lang = "phantom_data"]
>> #[stable(feature = "rust1", since = "1.0.0")]
>> pub struct PhantomData<T: ?Sized>;
>>
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> Hash for PhantomData<T> {
>>      #[inline]
>>      fn hash<H: Hasher>(&self, _: &mut H) {}
>> }
>>
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> cmp::PartialEq for PhantomData<T> {
>>      fn eq(&self, _other: &PhantomData<T>) -> bool {
>>          true
>>      }
>> }
>>
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> cmp::Eq for PhantomData<T> {}
>>
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> cmp::PartialOrd for PhantomData<T> {
>>      fn partial_cmp(&self, _other: &PhantomData<T>) -> Option<cmp::Ordering>
>> { Option::Some(cmp::Ordering::Equal)
>>      }
>> }
>>
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> cmp::Ord for PhantomData<T> {
>>      fn cmp(&self, _other: &PhantomData<T>) -> cmp::Ordering {
>>          cmp::Ordering::Equal
>>      }
>> }
>>
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> Copy for PhantomData<T> {}
>>
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> Clone for PhantomData<T> {
>>      fn clone(&self) -> Self {
>>          Self
>>      }
>> }
>>
>> #[stable(feature = "rust1", since = "1.0.0")]
>> impl<T: ?Sized> Default for PhantomData<T> {
>>      fn default() -> Self {
>>          Self
>>      }
>> }
>>
>> #[unstable(feature = "structural_match", issue = "31434")]
>> impl<T: ?Sized> StructuralPartialEq for PhantomData<T> {}
>>
>> /// Compiler-internal trait used to indicate the type of enum discriminants.
>> ///
>> /// This trait is automatically implemented for every type and does not add
>> any /// guarantees to [`mem::Discriminant`]. It is **undefined behavior**
>> to transmute /// between `DiscriminantKind::Discriminant` and
>> `mem::Discriminant`. ///
>> /// [`mem::Discriminant`]: crate::mem::Discriminant
>> #[unstable(
>>      feature = "discriminant_kind",
>>      issue = "none",
>>      reason = "this trait is unlikely to ever be stabilized, use
>> `mem::discriminant` instead" )]
>> #[lang = "discriminant_kind"]
>> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =
>> false))] #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
>> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
>> pub trait DiscriminantKind {
>>      /// The type of the discriminant, which must satisfy the trait
>>      /// bounds required by `mem::Discriminant`.
>>      #[lang = "discriminant_type"]
>>      type Discriminant: Clone + Copy + Debug + Eq + PartialEq + Hash + Send +
>> Sync + Unpin; }
>>
>> /// Used to determine whether a type contains
>> /// any `UnsafeCell` internally, but not through an indirection.
>> /// This affects, for example, whether a `static` of that type is
>> /// placed in read-only static memory or writable static memory.
>> /// This can be used to declare that a constant with a generic type
>> /// will not contain interior mutability, and subsequently allow
>> /// placing the constant behind references.
>> ///
>> /// # Safety
>> ///
>> /// This trait is a core part of the language, it is just expressed as a
>> trait in libcore for /// convenience. Do *not* implement it for other
>> types.
>> // FIXME: Eventually this trait should become `#[rustc_deny_explicit_impl]`.
>> // That requires porting the impls below to native internal impls. #[lang =
>> "freeze"]
>> #[unstable(feature = "freeze", issue = "121675")]
>> pub unsafe auto trait Freeze {}
>>
>> #[unstable(feature = "freeze", issue = "121675")]
>> impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
>> marker_impls! {
>>      #[unstable(feature = "freeze", issue = "121675")]
>>      unsafe Freeze for
>>          {T: ?Sized} PhantomData<T>,
>>          {T: ?Sized} *const T,
>>          {T: ?Sized} *mut T,
>>          {T: ?Sized} &T,
>>          {T: ?Sized} &mut T,
>> }
>>
>> /// Types that do not require any pinning guarantees.
>> ///
>> /// For information on what "pinning" is, see the [`pin` module]
>> documentation. ///
>> /// Implementing the `Unpin` trait for `T` expresses the fact that `T` is
>> pinning-agnostic: /// it shall not expose nor rely on any pinning
>> guarantees. This, in turn, means that a /// `Pin`-wrapped pointer to such a
>> type can feature a *fully unrestricted* API. /// In other words, if `T:
>> Unpin`, a value of type `T` will *not* be bound by the invariants /// which
>> pinning otherwise offers, even when "pinned" by a [`Pin<Ptr>`] pointing at
>> it. /// When a value of type `T` is pointed at by a [`Pin<Ptr>`], [`Pin`]
>> will not restrict access /// to the pointee value like it normally would,
>> thus allowing the user to do anything that they /// normally could with a
>> non-[`Pin`]-wrapped `Ptr` to that value. ///
>> /// The idea of this trait is to alleviate the reduced ergonomics of APIs
>> that require the use /// of [`Pin`] for soundness for some types, but which
>> also want to be used by other types that /// don't care about pinning. The
>> prime example of such an API is [`Future::poll`]. There are many ///
>> [`Future`] types that don't care about pinning. These futures can implement
>> `Unpin` and /// therefore get around the pinning related restrictions in
>> the API, while still allowing the /// subset of [`Future`]s which *do*
>> require pinning to be implemented soundly. ///
>> /// For more discussion on the consequences of [`Unpin`] within the wider
>> scope of the pinning /// system, see the [section about `Unpin`] in the
>> [`pin` module]. ///
>> /// `Unpin` has no consequence at all for non-pinned data. In particular,
>> [`mem::replace`] happily /// moves `!Unpin` data, which would be immovable
>> when pinned ([`mem::replace`] works for any /// `&mut T`, not just when `T:
>> Unpin`).
>> ///
>> /// *However*, you cannot use [`mem::replace`] on `!Unpin` data which is
>> *pinned* by being wrapped /// inside a [`Pin<Ptr>`] pointing at it. This is
>> because you cannot (safely) use a /// [`Pin<Ptr>`] to get a `&mut T` to its
>> pointee value, which you would need to call /// [`mem::replace`], and
>> *that* is what makes this system work.
>> ///
>> /// So this, for example, can only be done on types implementing `Unpin`:
>> ///
>> /// ```rust
>> /// # #![allow(unused_must_use)]
>> /// use std::mem;
>> /// use std::pin::Pin;
>> ///
>> /// let mut string = "this".to_string();
>> /// let mut pinned_string = Pin::new(&mut string);
>> ///
>> /// // We need a mutable reference to call `mem::replace`.
>> /// // We can obtain such a reference by (implicitly) invoking
>> `Pin::deref_mut`, /// // but that is only possible because `String`
>> implements `Unpin`. /// mem::replace(&mut *pinned_string,
>> "other".to_string());
>> /// ```
>> ///
>> /// This trait is automatically implemented for almost every type. The
>> compiler is free /// to take the conservative stance of marking types as
>> [`Unpin`] so long as all of the types that /// compose its fields are also
>> [`Unpin`]. This is because if a type implements [`Unpin`], then it /// is
>> unsound for that type's implementation to rely on pinning-related
>> guarantees for soundness, /// *even* when viewed through a "pinning"
>> pointer! It is the responsibility of the implementor of /// a type that
>> relies upon pinning for soundness to ensure that type is *not* marked as
>> [`Unpin`] /// by adding [`PhantomPinned`] field. For more details, see the
>> [`pin` module] docs. ///
>> /// [`mem::replace`]: crate::mem::replace "mem replace"
>> /// [`Future`]: crate::future::Future "Future"
>> /// [`Future::poll`]: crate::future::Future::poll "Future poll"
>> /// [`Pin`]: crate::pin::Pin "Pin"
>> /// [`Pin<Ptr>`]: crate::pin::Pin "Pin"
>> /// [`pin` module]: crate::pin "pin module"
>> /// [section about `Unpin`]: crate::pin#unpin "pin module docs about unpin"
>> /// [`unsafe`]: ../../std/keyword.unsafe.html "keyword unsafe"
>> #[stable(feature = "pin", since = "1.33.0")]
>> #[diagnostic::on_unimplemented(
>>      note = "consider using the `pin!` macro\nconsider using `Box::pin` if
>> you need to access the pinned value outside of the current scope", message
>> = "`{Self}` cannot be unpinned"
>> )]
>> #[lang = "unpin"]
>> pub auto trait Unpin {}
>>
>> /// A marker type which does not implement `Unpin`.
>> ///
>> /// If a type contains a `PhantomPinned`, it will not implement `Unpin` by
>> default. #[stable(feature = "pin", since = "1.33.0")]
>> #[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
>> pub struct PhantomPinned;
>>
>> #[stable(feature = "pin", since = "1.33.0")]
>> impl !Unpin for PhantomPinned {}
>>
>> marker_impls! {
>>      #[stable(feature = "pin", since = "1.33.0")]
>>      Unpin for
>>          {T: ?Sized} &T,
>>          {T: ?Sized} &mut T,
>> }
>>
>> marker_impls! {
>>      #[stable(feature = "pin_raw", since = "1.38.0")]
>>      Unpin for
>>          {T: ?Sized} *const T,
>>          {T: ?Sized} *mut T,
>> }
>>
>> /// A marker for types that can be dropped.
>> ///
>> /// This should be used for `~const` bounds,
>> /// as non-const bounds will always hold for every type.
>> #[unstable(feature = "const_destruct", issue = "133214")]
>> #[lang = "destruct"]
>> #[rustc_on_unimplemented(message = "can't drop `{Self}`", append_const_msg)]
>> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =
>> false))] #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
>> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
>> #[cfg_attr(not(bootstrap), const_trait)]
>> pub trait Destruct {}
>>
>> /// A marker for tuple types.
>> ///
>> /// The implementation of this trait is built-in and cannot be implemented
>> /// for any user type.
>> #[unstable(feature = "tuple_trait", issue = "none")]
>> #[lang = "tuple_trait"]
>> #[diagnostic::on_unimplemented(message = "`{Self}` is not a tuple")]
>> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =
>> false))] #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
>> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
>> pub trait Tuple {}
>>
>> /// A marker for pointer-like types.
>> ///
>> /// This trait can only be implemented for types that are certain to have
>> /// the same size and alignment as a [`usize`] or [`*const ()`](pointer).
>> /// To ensure this, there are special requirements on implementations
>> /// of `PointerLike` (other than the already-provided implementations
>> /// for built-in types):
>> ///
>> /// * The type must have `#[repr(transparent)]`.
>> /// * The type’s sole non-zero-sized field must itself implement
>> `PointerLike`. #[unstable(feature = "pointer_like_trait", issue = "none")]
>> #[lang = "pointer_like"]
>> #[diagnostic::on_unimplemented(
>>      message = "`{Self}` needs to have the same ABI as a pointer",
>>      label = "`{Self}` needs to be a pointer-like type"
>> )]
>> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
>> pub trait PointerLike {}
>>
>> #[cfg(not(bootstrap))]
>> marker_impls! {
>>      #[unstable(feature = "pointer_like_trait", issue = "none")]
>>      PointerLike for
>>          isize,
>>          usize,
>>          {T} &T,
>>          {T} &mut T,
>>          {T} *const T,
>>          {T} *mut T,
>>          {T: PointerLike} crate::pin::Pin<T>,
>> }
>>
>> /// A marker for types which can be used as types of `const` generic
>> parameters. ///
>> /// These types must have a proper equivalence relation (`Eq`) and it must
>> be automatically /// derived (`StructuralPartialEq`). There's a hard-coded
>> check in the compiler ensuring /// that all fields are also `ConstParamTy`,
>> which implies that recursively, all fields /// are `StructuralPartialEq`.
>> #[lang = "const_param_ty"]
>> #[unstable(feature = "unsized_const_params", issue = "95174")]
>> #[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const
>> parameter type")] #[allow(multiple_supertrait_upcastable)]
>> // We name this differently than the derive macro so that the
>> `adt_const_params` can // be used independently of `unsized_const_params`
>> without requiring a full path // to the derive macro every time it is used.
>> This should be renamed on stabilization. pub trait ConstParamTy_:
>> UnsizedConstParamTy + StructuralPartialEq + Eq {}
>>
>> /// Derive macro generating an impl of the trait `ConstParamTy`.
>> #[rustc_builtin_macro]
>> #[allow_internal_unstable(unsized_const_params)]
>> #[unstable(feature = "adt_const_params", issue = "95174")]
>> pub macro ConstParamTy($item:item) {
>>      /* compiler built-in */
>> }
>>
>> #[lang = "unsized_const_param_ty"]
>> #[unstable(feature = "unsized_const_params", issue = "95174")]
>> #[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const
>> parameter type")] /// A marker for types which can be used as types of
>> `const` generic parameters. ///
>> /// Equivalent to [`ConstParamTy_`] except that this is used by
>> /// the `unsized_const_params` to allow for fake unstable impls.
>> pub trait UnsizedConstParamTy: StructuralPartialEq + Eq {}
>>
>> /// Derive macro generating an impl of the trait `ConstParamTy`.
>> #[rustc_builtin_macro]
>> #[allow_internal_unstable(unsized_const_params)]
>> #[unstable(feature = "unsized_const_params", issue = "95174")]
>> pub macro UnsizedConstParamTy($item:item) {
>>      /* compiler built-in */
>> }
>>
>> // FIXME(adt_const_params): handle `ty::FnDef`/`ty::Closure`
>> marker_impls! {
>>      #[unstable(feature = "adt_const_params", issue = "95174")]
>>      ConstParamTy_ for
>>          usize, u8, u16, u32, u64, u128,
>>          isize, i8, i16, i32, i64, i128,
>>          bool,
>>          char,
>>          (),
>>          {T: ConstParamTy_, const N: usize} [T; N],
>> }
>>
>> marker_impls! {
>>      #[unstable(feature = "unsized_const_params", issue = "95174")]
>>      UnsizedConstParamTy for
>>          usize, u8, u16, u32, u64, u128,
>>          isize, i8, i16, i32, i64, i128,
>>          bool,
>>          char,
>>          (),
>>          {T: UnsizedConstParamTy, const N: usize} [T; N],
>>
>>          str,
>>          {T: UnsizedConstParamTy} [T],
>>          {T: UnsizedConstParamTy + ?Sized} &T,
>> }
>>
>> /// A common trait implemented by all function pointers.
>> #[unstable(
>>      feature = "fn_ptr_trait",
>>      issue = "none",
>>      reason = "internal trait for implementing various traits for all
>> function pointers" )]
>> #[lang = "fn_ptr_trait"]
>> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =
>> false))] #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
>> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
>> pub trait FnPtr: Copy + Clone {
>>      /// Returns the address of the function pointer.
>>      #[lang = "fn_ptr_addr"]
>>      fn addr(self) -> *const ();
>> }
>>
>> /// Derive macro generating impls of traits related to smart pointers.
>> #[rustc_builtin_macro(CoercePointee, attributes(pointee))]
>> #[allow_internal_unstable(dispatch_from_dyn, coerce_unsized, unsize)]
>> #[unstable(feature = "derive_coerce_pointee", issue = "123430")]
>> #[cfg(not(bootstrap))]
>> pub macro CoercePointee($item:item) {
>>      /* compiler built-in */
>> }
>>
>>
>> ```
>>
>>
>> In GNU Emacs 31.0.50 (build 1, x86_64-pc-linux-gnu, GTK+ Version
>>   3.24.43, cairo version 1.18.2) of 2025-04-17 built on Mufasa
>> Repository revision: 7b35a5062231ec5a11c7a87d4797cfb5dba25121
>> Repository branch: feature/igc
>> System Description: NixOS 24.11 (Vicuna)
>>
>> Configured using:
>>   'configure 'CFLAGS=-O3 -march=native'
>>   --prefix=/home/exec/Projects/git.savannah.gnu.org/git/emacs-build/feature_i
>> gc-7b35a5062231ec5a11c7a87d4797cfb5dba25121-O3 --with-mps=yes
>> --with-imagemagick --with-modules --with-pgtk
>>   --with-cairo --with-cairo-xcb --without-compress-install
>>   --with-mailutils --with-tree-sitter --with-xinput2
>>   --enable-link-time-optimization --with-file-notification=inotify'
>>
>> Configured features:
>> ACL CAIRO DBUS FREETYPE GIF GLIB GMP GNUTLS GSETTINGS HARFBUZZ
>> IMAGEMAGICK JPEG LCMS2 LIBOTF LIBXML2 MODULES MPS NATIVE_COMP NOTIFY
>> INOTIFY PDUMPER PGTK PNG RSVG SECCOMP SOUND SQLITE3 THREADS TIFF
>> TOOLKIT_SCROLL_BARS TREE_SITTER WEBP XIM GTK3 ZLIB
>>
>> Important settings:
>>    value of $LC_COLLATE: C
>>    value of $LC_MONETARY: en_US.UTF-8
>>    value of $LC_NUMERIC: en_US.UTF-8
>>    value of $LC_TIME: C
>>    value of $LANG: en_US.UTF-8
>>    value of $XMODIFIERS: @im=fcitx
>>    locale-coding-system: utf-8-unix
>>
>> Major mode: Elisp/l
>>
>> Minor modes in effect:
>>    restore-point-mode: t
>>    global-atomic-chrome-edit-mode: t
>>    global-git-gutter-mode: t
>>    git-gutter-mode: t
>>    marginalia-mode: t
>>    elisp-def-mode: t
>>    flycheck-posframe-mode: t
>>    hungry-delete-mode: t
>>    symbol-overlay-mode: t
>>    keycast-tab-bar-mode: t
>>    vertico-truncate-mode: t
>>    vertico-multiform-mode: t
>>    vertico-mode: t
>>    telega-root-auto-fill-mode: t
>>    telega-contact-birthdays-mode: t
>>    telega-active-video-chats-mode: t
>>    telega-active-locations-mode: t
>>    telega-patrons-mode: t
>>    telega-active-stories-mode: t
>>    tab-line-nerd-icons-global-mode: t
>>    global-tab-line-mode: t
>>    tab-line-mode: t
>>    ultra-scroll-mode: t
>>    pixel-scroll-precision-mode: t
>>    org-roam-db-autosync-mode: t
>>    global-org-modern-mode: t
>>    mu4e-modeline-mode: t
>>    global-kkp-mode: t
>>    global-git-commit-mode: t
>>    flycheck-mode: t
>>    engine-mode: t
>>    symex-mode: t
>>    global-evil-surround-mode: t
>>    evil-surround-mode: t
>>    yas-global-mode: t
>>    yas-minor-mode: t
>>    corfu-terminal-mode: t
>>    corfu-history-mode: t
>>    global-corfu-mode: t
>>    corfu-mode: t
>>    rainbow-mode: t
>>    elisp-autofmt-mode: t
>>    highlight-defined-mode: t
>>    highlight-numbers-mode: t
>>    hes-mode: t
>>    rainbow-delimiters-mode: t
>>    burly-tabs-mode: t
>>    global-form-feed-st-mode: t
>>    form-feed-st-mode: t
>>    eat-eshell-mode: t
>>    sly-symbol-completion-mode: t
>>    super-save-mode: t
>>    savehist-mode: t
>>    which-key-mode: t
>>    super-hint-xref-mode: t
>>    super-hint-rg-mode: t
>>    windmove-mode: t
>>    server-mode: t
>>    save-place-mode: t
>>    recentf-mode: t
>>    winner-mode: t
>>    persistent-scratch-autosave-mode: t
>>    global-dash-fontify-mode: t
>>    dash-fontify-mode: t
>>    nerd-icons-completion-mode: t
>>    sudo-edit-indicator-mode: t
>>    global-evil-visualstar-mode: t
>>    evil-visualstar-mode: t
>>    evil-commentary-mode: t
>>    global-evil-mc-mode: t
>>    evil-mc-mode: t
>>    evil-lion-mode: t
>>    global-evil-collection-unimpaired-mode: t
>>    evil-collection-unimpaired-mode: t
>>    buffer-face-mode: t
>>    TeX-PDF-mode: t
>>    display-line-numbers-mode: t
>>    electric-pair-mode: t
>>    global-auto-revert-mode: t
>>    evil-mode: t
>>    evil-local-mode: t
>>    general-override-mode: t
>>    minions-mode: t
>>    el-patch-use-package-mode: t
>>    elpaca-use-package-mode: t
>>    override-global-mode: t
>>    tooltip-mode: t
>>    global-eldoc-mode: t
>>    eldoc-mode: t
>>    show-paren-mode: t
>>    electric-indent-mode: t
>>    mouse-wheel-mode: t
>>    tab-bar-mode: t
>>    file-name-shadow-mode: t
>>    context-menu-mode: t
>>    global-font-lock-mode: t
>>    font-lock-mode: t
>>    minibuffer-regexp-mode: t
>>    column-number-mode: -1
>>    line-number-mode: -1
>>    transient-mark-mode: t
>>    auto-composition-mode: t
>>    auto-encryption-mode: t
>>    auto-compression-mode: t
>>
>> Load-path shadows:
>> /home/exec/.emacs.d/elpaca/builds/modus-themes/theme-loaddefs hides
>> /home/exec/.emacs.d/elpaca/builds/standard-themes/theme-loaddefs
>> /home/exec/.emacs.d/elpaca/builds/modus-themes/theme-loaddefs hides
>> /home/exec/.emacs.d/elpaca/builds/ef-themes/theme-loaddefs
>> /home/exec/.emacs.d/elpaca/builds/modus-themes/theme-loaddefs hides
>> /home/exec/Projects/git.savannah.gnu.org/git/emacs-build/feature_igc-7b35a5
>> 062231ec5a11c7a87d4797cfb5dba25121-O3/share/emacs/31.0.50/lisp/theme-loaddef
>> s /home/exec/.emacs.d/elpaca/builds/transient/transient hides
>> /home/exec/Projects/git.savannah.gnu.org/git/emacs-build/feature_igc-7b35a5
>> 062231ec5a11c7a87d4797cfb5dba25121-O3/share/emacs/31.0.50/lisp/transient
>>
>> Features:
>> (shadow sort mail-extr expand-region yaml-mode-expansions
>> subword-mode-expansions text-mode-expansions cc-mode-expansions
>> the-org-mode-expansions python-el-fgallina-expansions
>> latex-mode-expansions js2-mode-expansions js-mode-expansions
>> web-mode-expansions html-mode-expansions clojure-mode-expansions
>> er-basic-expansions expand-region-core expand-region-custom
>> evil-collection-embark embark-org embark-consult embark gptel-curl
>> nerd-icons-dired diredfl info-colors vertico-sort cus-start descr-text
>> dabbrev cape lsp-diagnostics lsp-modeline lsp-icons lsp-zig lsp-yang
>> lsp-yaml lsp-xml lsp-wgsl lsp-volar lsp-vimscript lsp-vhdl lsp-vetur
>> lsp-html lsp-verilog lsp-vala lsp-v lsp-typespec lsp-typeprof lsp-ttcn3
>> lsp-ts-query lsp-trunk lsp-toml lsp-tilt lsp-tex lsp-terraform
>> lsp-svelte lsp-steep lsp-sqls lsp-sql lsp-sorbet lsp-solidity
>> lsp-solargraph lsp-semgrep lsp-ruff lsp-ruby-syntax-tree lsp-ruby-lsp
>> lsp-rubocop lsp-roslyn lsp-roc lsp-rf lsp-remark lsp-racket lsp-r
>> lsp-qml lsp-pyright lsp-pylsp lsp-pyls lsp-pwsh lsp-purescript lsp-pls
>> lsp-php lsp-perlnavigator lsp-perl lsp-openscad lsp-ocaml lsp-nushell
>> lsp-nix lsp-nim lsp-nginx lsp-nextflow lsp-move lsp-mojo lsp-mint
>> lsp-meson lsp-mdx lsp-matlab lsp-marksman lsp-markdown lsp-magik
>> lsp-fennel lsp-lua lsp-lisp lsp-kubernetes-helm lsp-kotlin lsp-json
>> lsp-jq lsp-javascript lsp-idris lsp-haxe lsp-hack lsp-groovy lsp-graphql
>> lsp-golangci-lint lsp-glsl lsp-gleam lsp-gdscript lsp-fsharp lsp-futhark
>> lsp-fortran lsp-eslint lsp-erlang lsp-emmet lsp-elm lsp-elixir
>> lsp-earthly lsp-dockerfile lsp-dhall lsp-d lsp-cypher lsp-cucumber
>> lsp-copilot lsp-css lsp-c3 lsp-csharp lsp-crystal lsp-credo lsp-cobol
>> lsp-cmake lsp-clojure lsp-clangd lsp-bufls lsp-go lsp-completion
>> lsp-beancount lsp-bash lsp-awk lsp-autotools lsp-astro lsp-asm
>> lsp-ansible lsp-angular lsp-ada lsp-actionscript copilot
>> copilot-balancer editorconfig editorconfig-core editorconfig-core-handle
>> editorconfig-fnmatch jsonrpc gptel-openai-extras gptel-anthropic
>> gptel-gemini gptel-ollama org-indent gptel-openai consult-dir-autoloads
>> consult-ag-autoloads restore-point evil-collection-atomic-chrome
>> atomic-chrome git-gutter marginalia elisp-def evil-collection-ert ert
>> flycheck-posframe evil-collection-hungry-delete hungry-delete
>> symbol-overlay keycast zig-mode reformatter empv vertico-truncate
>> vertico-posframe vertico-multiform evil-collection-vertico vertico
>> lsp-uniteai nix-ts-mode go-translate gt-text-utility gt-engine-echo
>> gt-engine-libre gt-engine-chatgpt gt-engine-youdao gt-engine-osxdict
>> gt-engine-stardict gt-engine-deepl gt-engine-google-rpc gt-engine-google
>> gt-engine-bing gt-extension gt-faces gt-core gt-httpx sdcv cap-words
>> superword subword evil-collection-telega telega-obsolete telega
>> telega-tdlib-events telega-match telega-root telega-info telega-chat
>> telega-modes telega-company telega-emoji telega-user
>> telega-notifications telega-voip telega-msg telega-story telega-webpage
>> telega-tme telega-sticker telega-vvnote telega-ffplay telega-i18n
>> telega-sort telega-filter telega-ins telega-inline telega-util
>> telega-folders telega-topic telega-media telega-tdlib telega-server
>> telega-core telega-customize emacsbug tab-line-nerd-icons
>> evil-collection-imenu-list imenu-list tab-line rust-utils
>> rust-mode-treesitter rust-ts-mode rust-mode rust-playpen rust-cargo
>> rust-common rust-rustfmt rust-compile cargo cargo-process rg-info-hack
>> rg-menu rg-ibuffer ibuf-macs rg-result wgrep-rg rg-history ibuf-ext
>> evil-collection-ibuffer ibuffer ibuffer-loaddefs rg-header
>> evil-collection-ultra-scroll ultra-scroll pixel-scroll cua-base
>> org-sliced-images emacsql-sqlite-builtin evil-collection-org-roam
>> org-roam-migrate org-roam-log org-roam-mode org-roam-capture org-roam-id
>> org-roam-node org-roam-db org-roam-utils org-roam-compat org-roam
>> org-capture emacsql-sqlite emacsql emacsql-compiler org-journal
>> org-crypt cal-iso org-modern orderless evil-collection-mu4e mu4e
>> mu4e-org mu4e-notification mu4e-main smtpmail mu4e-view mu4e-mime-parts
>> mu4e-headers mu4e-thread mu4e-actions mu4e-compose mu4e-draft gnus-msg
>> gnus-art mm-uu mml2015 mu4e-search mu4e-lists mu4e-bookmarks mu4e-mark
>> mu4e-message flow-fill mu4e-contacts mu4e-update mu4e-folders
>> mu4e-context mu4e-query-items mu4e-server mu4e-modeline mu4e-vars
>> mu4e-helpers mu4e-config mu4e-window ido mu4e-obsolete cyphejor qml-mode
>> kkp rfc-mode string-inflection wakatime-mode systemd minuet pr-review
>> pr-review-render pr-review-action magit-diff git-commit
>> evil-collection-log-edit log-edit pcvs-util add-log magit-core
>> magit-autorevert magit-margin magit-transient magit-process
>> evil-collection-with-editor with-editor magit-mode magit-git magit-base
>> pr-review-input pr-review-api ghub-graphql treepy gsexp ghub
>> pr-review-common consult-lsp lsp-ui lsp-ui-flycheck lsp-ui-doc
>> evil-collection-lsp-ui-imenu lsp-ui-imenu lsp-ui-peek lsp-ui-sideline
>> lsp-rust lsp-semantic-tokens lsp-mode network-stream
>> evil-collection-markdown-mode markdown-mode lsp-ui-util lsp-protocol
>> llm-prompt groovy-mode iedit help-macro iedit-lib hide-comnt
>> minibuffer-header gptel-quick gotest fzf flycheck-clj-kondo jka-compr
>> pos-tip consult-flycheck flycheck-rust engine-mode evil-collection-ement
>> ement-room-list taxy-magit-section taxy ement ement-notifications
>> ement-notify ement-room ewoc ement-lib ement-api ement-structs
>> ement-macros dns llm-ollama llm-provider-utils llm-models
>> llm-request-plz plz-event-source plz-media-type plz llm symex symex-evil
>> symex-evil-support symex-hydra symex-transformations
>> symex-transformations-lisp symex-utils evil-cleverparens
>> evil-cleverparens-text-objects evil-cleverparens-util smartparens
>> evil-surround symex-misc symex-interface-builtins symex-interface-fennel
>> symex-interface-arc symex-interface-common-lisp symex-interface-clojure
>> symex-interface-scheme symex-interface-racket symex-interface-elisp
>> symex-interop symex-interface symex-traversals symex-dsl symex-evaluator
>> symex-computations symex-primitives symex-ts symex-utils-ts
>> symex-transformations-ts symex-primitives-lisp symex-data symex-ui
>> symex-custom evil-collection-lispy lispy le-clojure delsel lispy-inline
>> avy lispy-tags zoutline combobulate evil-collection-elfeed elfeed-show
>> elfeed-search elfeed-csv elfeed elfeed-curl elfeed-log elfeed-db
>> elfeed-lib xml-query dired-git-info dired-hacks dired-preview
>> evil-collection-cmake-mode cmake-mode consult-yasnippet yasnippet-capf
>> yasnippet-snippets yasnippet kind-icon svg-lib corfu-terminal popon
>> corfu-popupinfo corfu-indexed corfu-history evil-collection-corfu corfu
>> consult-ls-git paredit clojure-ts-mode evil-collection-cider cider
>> tramp-sh cider-debug cider-browse-ns cider-mode cider-xref-backend
>> cider-find cider-inspector cider-completion cider-profile cider-eval
>> cider-jar cider-repl-history cider-repl cider-resolve cider-test
>> cider-overlays cider-stacktrace cider-doc cider-browse-spec
>> cider-clojuredocs cider-eldoc cider-docstring cider-client cider-common
>> cider-completion-context cider-connection cider-popup sesman-browser
>> nrepl-client cider-util sesman queue nrepl-dict spinner clojure-mode
>> rainbow-mode elisp-autofmt loadhist highlight-defined highlight-numbers
>> parent-mode highlight-escape-sequences rainbow-delimiters chatgpt-shell
>> chatgpt-shell-prompt-compose chatgpt-shell-perplexity
>> chatgpt-shell-openrouter chatgpt-shell-openai chatgpt-shell-ollama
>> chatgpt-shell-kagi chatgpt-shell-google chatgpt-shell-deepseek
>> chatgpt-shell-anthropic evil-collection-smerge-mode smerge-mode diff
>> shell-maker ielm evil-collection-eshell eshell em-prompt esh-mode
>> esh-var esh-cmd esh-ext esh-proc esh-opt esh-io esh-arg esh-module
>> esh-module-loaddefs esh-util cargo-jump-xref toml breadcrumb pulse
>> bookmark-in-project bookmark+ bookmark+-key bookmark+-1 gnus-sum
>> gnus-group gnus-undo gnus-start gnus-dbus gnus-cloud nnimap nnmail
>> mail-source utf7 nnoo gnus-spec gnus-int gnus-range gnus-win
>> bookmark+-bmu bookmark+-lit bookmark+-mac babashka parseedn
>> parseclj-parser parseclj-lex parseclj-alist cnfonts burly-tabs burly
>> compile-multi form-feed-st google-this echo-bar fcitx
>> evil-collection-eat eat term/xterm xterm evil-collection-term term ehelp
>> ox-reveal ox-odt rng-loc rng-uri rng-parse rng-match rng-dt rng-util
>> rng-pttrn nxml-parse nxml-ns nxml-enc xmltok nxml-util ox-latex
>> ox-icalendar org-agenda ox-html table ox-ascii ox-publish ox org-attach
>> org-element org-persist org-id org-refile org-element-ast inline
>> avl-tree htmlize evil-collection-explain-pause-mode explain-pause-mode
>> explain-pause-top explain-pause-log-to-socket evil-collection-profiler
>> profiler weather-metno solar cal-dst url-cache display-wttr kdeconnect
>> crux pest-mode popwin modus-themes blackboard-theme standard-themes
>> nimbus-theme tok-theme danneskjold-theme srcery-theme subatomic256-theme
>> iscroll xml+ evil-textobj-tree-sitter
>> evil-textobj-tree-sitter-thing-at-point evil-textobj-tree-sitter-core
>> tree-sitter tree-sitter-load tree-sitter-cli tsc tsc-dyn tsc-dyn-get
>> dired-aux tsc-obsolete ctable evil-collection-color-rg color-rg
>> line-reminder ov ht fringe-helper solarized-theme solarized
>> solarized-faces sqlup-mode evil-collection-bm bm zen-mode
>> evil-collection-sly sly gud sly-completion sly-buttons sly-messages
>> sly-common evil-collection-apropos apropos evil-collection-arc-mode
>> arc-mode archive-mode hyperspec sicp base16-theme idea-darkula-theme
>> hybrid-reverse-theme material-theme doom-themes doom-themes-base
>> nyan-mode organic-green-theme inkpot-theme github-dark-vscode-theme
>> almost-mono-themes cyberpunk-theme soothe-theme soothe-tva zenburn-theme
>> mindre-theme kaolin-themes kaolin-themes-lib tron-legacy-theme
>> wildcharm-theme atom-one-dark-theme parchment-theme autothemer
>> visual-fill-column transpose-frame gameoflife evil-collection-docker
>> docker docker-context docker-volume docker-network docker-image
>> docker-container docker-faces docker-core docker-compose docker-process
>> docker-utils docker-group aio dockerfile-mode emacs-everywhere cus-dir
>> dumb-jump evil-collection-popup popup websocket bindat bing-dict cl
>> bing-dict-cache hl-todo atom-dark-theme ef-themes uwu-theme vagrant
>> evil-collection-ag ag vc-svn find-dired alarm-clock alert log4e
>> notifications gntp pinentry evil-collection-hackernews hackernews
>> evil-collection-notmuch notmuch notmuch-tree notmuch-jump notmuch-hello
>> notmuch-show notmuch-print notmuch-crypto notmuch-mua notmuch-message
>> notmuch-draft notmuch-maildir-fcc notmuch-address notmuch-company
>> notmuch-parser notmuch-wash coolj goto-addr icalendar diary-lib
>> diary-loaddefs notmuch-tag notmuch-lib notmuch-compat message sendmail
>> yank-media rfc822 mml mailabbrev gmm-utils mm-view mml-smime mml-sec
>> smime gnutls dig mm-decode mm-bodies mm-encode fussy flx affe
>> evil-collection-consult consult clang-format apheleia apheleia-rcs
>> apheleia-dp apheleia-formatters apheleia-utils apheleia-log
>> apheleia-formatter-context vimrc-mode gnuplot olivetti super-save
>> evil-collection-helpful helpful cc-langs trace cl-print
>> evil-collection-edebug edebug evil-collection-debug debug backtrace
>> info-look evil-collection-info info help-fns radix-tree
>> evil-collection-elisp-refs elisp-refs solidity-mode solidity-common
>> evil-collection-git-timemachine git-timemachine web-mode disp-table
>> evil-collection-go-mode go-mode find-file evil-collection-js2-mode
>> js2-mode etags fileloop zig-mode-autoloads reformatter-autoloads
>> empv-autoloads yasnippet-snippets-autoloads marginalia-autoloads
>> vertico-truncate-autoloads vertico-posframe-autoloads vertico-autoloads
>> lsp-uniteai-autoloads nix-ts-mode-autoloads go-translate-autoloads
>> alert-autoloads gntp-autoloads log4e-autoloads sdcv-autoloads
>> telega-autoloads tab-line-nerd-icons-autoloads keycast-autoloads
>> rust-mode-autoloads cargo-autoloads toml-autoloads rg-autoloads
>> writeroom-mode-autoloads nov-autoloads esxml-autoloads kv-autoloads
>> makefile-executor-autoloads ultra-scroll-autoloads pdf-tools-autoloads
>> org-sliced-images-autoloads consult-org-roam-autoloads
>> org-roam-autoloads org-journal-autoloads org-download-autoloads
>> org-modern-autoloads orderless-autoloads mu4e-autoloads
>> cyphejor-autoloads symbol-overlay-autoloads qml-mode-autoloads
>> kkp-autoloads rfc-mode-autoloads string-inflection-autoloads
>> wakatime-mode-autoloads webpaste-autoloads systemd-autoloads
>> minuet-autoloads pr-review-autoloads forge-autoloads closql-autoloads
>> emacsql-autoloads ghub-autoloads treepy-autoloads yaml-autoloads
>> lsp-pyright-autoloads consult-lsp-autoloads lsp-ui-autoloads
>> lsp-mode-autoloads groovy-mode-autoloads imenu-list-autoloads
>> hungry-delete-autoloads hide-comnt-autoloads minibuffer-header-autoloads
>> gptel-quick-autoloads gptel-autoloads gotest-autoloads fzf-autoloads
>> flycheck-golangci-lint-autoloads flycheck-clj-kondo-autoloads
>> pos-tip-autoloads consult-flycheck-autoloads flycheck-rust-autoloads
>> flycheck-posframe-autoloads flycheck-autoloads engine-mode-autoloads
>> ement-autoloads taxy-magit-section-autoloads taxy-autoloads
>> embark-consult-autoloads embark-autoloads ellama-autoloads llm-autoloads
>> plz-event-source-autoloads plz-media-type-autoloads plz-autoloads
>> symex-autoloads tree-sitter-autoloads tsc-autoloads lispy-autoloads
>> iedit-autoloads swiper-autoloads ivy-autoloads zoutline-autoloads
>> evil-cleverparens-autoloads smartparens-autoloads combobulate-autoloads
>> combobulate-go combobulate-json combobulate-yaml combobulate-css
>> combobulate-js-ts combobulate-python combobulate-html combobulate-toml
>> combobulate-cursor multiple-cursors mc-separate-operations
>> rectangular-region-mode mc-mark-pop mc-edit-lines
>> mc-hide-unmatched-lines-mode mc-mark-more sgml-mode mc-cycle-cursors
>> multiple-cursors-core combobulate-query savehist evil-collection-scheme
>> scheme combobulate-ui combobulate-display let-alist combobulate-ztree
>> combobulate-envelope combobulate-manipulation evil-collection-python
>> python combobulate-procedure combobulate-navigation combobulate-misc
>> combobulate-setup tempo combobulate-interface combobulate-settings
>> combobulate-rules elisp-def-autoloads elfeed-tube-mpv-autoloads
>> elfeed-tube-autoloads elfeed-autoloads eee-autoloads eee
>> dired-git-info-autoloads dired-hacks-autoloads dired-preview-autoloads
>> diredfl-autoloads git-gutter-autoloads cmake-mode-autoloads
>> consult-yasnippet-autoloads yasnippet-capf-autoloads yasnippet-autoloads
>> cape-autoloads kind-icon-autoloads svg-lib-autoloads
>> corfu-terminal-autoloads popon-autoloads corfu-autoloads
>> copilot-autoloads copilot-chat-autoloads consult-ls-git-autoloads
>> paredit-autoloads clojure-ts-mode-autoloads cider-autoloads
>> clojure-mode-autoloads queue-autoloads spinner-autoloads
>> sesman-autoloads chatgpt-shell-autoloads shell-maker-autoloads
>> cargo-jump-xref-autoloads breadcrumb-autoloads
>> bookmark-in-project-autoloads bookmark+-autoloads babashka-autoloads
>> parseedn-autoloads parseclj-autoloads aidermacs-autoloads
>> mediawiki-autoloads markdown-mode-autoloads treemacs-magit-autoloads
>> magit-autoloads with-editor-autoloads nerd-icons-ibuffer-autoloads
>> treemacs-nerd-icons-autoloads treemacs-autoloads pfuture-autoloads
>> cfrs-autoloads cnfonts-autoloads burly-autoloads compile-multi-autoloads
>> form-feed-st-autoloads google-this-autoloads echo-bar-autoloads
>> zoom-autoloads fcitx-autoloads eat-autoloads vterm-autoloads
>> chatgpt-autoloads polymode-autoloads ox-reveal-autoloads
>> htmlize-autoloads wordreference-autoloads explain-pause-mode-autoloads
>> weather-metno-autoloads display-wttr-autoloads kdeconnect-autoloads
>> emms-autoloads crux-autoloads pest-mode-autoloads popwin-autoloads
>> modus-themes-autoloads blackboard-theme-autoloads
>> standard-themes-autoloads nimbus-theme-autoloads tok-theme-autoloads
>> danneskjold-theme-autoloads srcery-theme-autoloads
>> subatomic256-theme-autoloads iscroll-autoloads xml+-autoloads
>> multiple-cursors-autoloads evil-textobj-tree-sitter-autoloads
>> evil-numbers-autoloads ctable-autoloads color-rg-autoloads
>> line-reminder-autoloads fringe-helper-autoloads ov-autoloads
>> solarized-theme-autoloads sqlup-mode-autoloads bm-autoloads
>> zen-mode-autoloads sly-autoloads expand-region-autoloads
>> highlight-defined-autoloads base16-theme-autoloads
>> idea-darkula-theme-autoloads hybrid-reverse-theme-autoloads
>> material-theme-autoloads doom-themes-autoloads nyan-mode-autoloads
>> organic-green-theme-autoloads inkpot-theme-autoloads
>> github-dark-vscode-theme-autoloads almost-mono-themes-autoloads
>> cyberpunk-theme-autoloads soothe-theme-autoloads zenburn-theme-autoloads
>> mindre-theme-autoloads kaolin-themes-autoloads
>> tron-legacy-theme-autoloads wildcharm-theme-autoloads
>> atom-one-dark-theme-autoloads parchment-theme-autoloads
>> autothemer-autoloads visual-fill-column-autoloads
>> transpose-frame-autoloads gameoflife-autoloads docker-autoloads
>> aio-autoloads dockerfile-mode-autoloads emacs-everywhere-autoloads
>> cus-dir-autoloads dumb-jump-autoloads popup-autoloads
>> bing-dict-autoloads hl-todo-autoloads atom-dark-theme-autoloads
>> ef-themes-autoloads uwu-theme-autoloads vagrant-autoloads ag-autoloads
>> alarm-clock-autoloads pinentry-autoloads hackernews-autoloads
>> notmuch-autoloads fussy-autoloads flx-autoloads affe-autoloads
>> consult-autoloads clang-format-autoloads apheleia-autoloads
>> elisp-autofmt-autoloads vimrc-mode-autoloads mpv-autoloads
>> gnuplot-autoloads mermaid-mode-autoloads atomic-chrome-autoloads
>> websocket-autoloads restore-point-autoloads ace-window-autoloads
>> avy-autoloads olivetti-autoloads super-save-autoloads helpful-autoloads
>> elisp-refs-autoloads solidity-mode-autoloads git-timemachine-autoloads
>> web-mode-autoloads adoc-mode-autoloads go-mode-autoloads
>> js2-mode-autoloads rust-playground-autoloads evil-collection-which-key
>> which-key super-hint-xref super-hint-rg super-hint evil-collection-xref
>> xref evil-collection-rg rg piper ob-shell ob-gnuplot ob-C
>> evil-collection-org org ob ob-tangle ob-ref ob-lob ob-table ob-exp
>> org-macro org-src evil-collection-sh-script sh-script executable
>> ob-comint org-pcomplete org-list org-footnote org-faces org-entities
>> ob-emacs-lisp ob-core ob-eval org-cycle org-table ol org-fold
>> org-fold-core org-keys oc org-loaddefs org-version org-compat org-macs
>> molecule-mode lsp hyperbole hideshow gptel-manual-complete
>> evil-collection-gptel gptel windmove evil-collection-flycheck flycheck
>> erc erc-backend erc-networks erc-common erc-compat erc-loaddefs
>> evil-collection-ediff ediff ediff-merg ediff-mult ediff-wind ediff-diff
>> ediff-help ediff-init ediff-util dired-x consult-ripgrep-all desktop
>> frameset server evil-collection-eww eww vtable mule-util url-queue
>> mm-url evil-collection-gnus gnus nnheader gnus-util range epa-file
>> evil-collection-epa epa derived epg rfc6068 epg-config saveplace recentf
>> tree-widget winner edit-list refine loop list-utils prompts file-info
>> browse-at-remote f image-roll evil-collection-image image-mode exif
>> toc-mode rst scratch sql evil-collection-view view persistent-scratch
>> exercism persist async-await iter2 generator promise url-http url-auth
>> mail-parse rfc2231 rfc2047 rfc2045 mm-util ietf-drums mail-prsvr url-gw
>> nsm promise-rejection-tracking promise-finally promise-done
>> promise-es6-extensions promise-core async request mailheader mail-utils
>> a indent-bars evil-collection-outline noutline outline mode-line-bell
>> powerthesaurus jeison dash s evil-collection-ripgrep ripgrep
>> evil-collection-wgrep wgrep evil-collection-grep grep
>> evil-collection-vlf vlf vlf-base vlf-tune gptai ctrlf hl-line
>> nerd-icons-completion nerd-icons nerd-icons-faces nerd-icons-data
>> nerd-icons-data-mdicon nerd-icons-data-flicon nerd-icons-data-codicon
>> nerd-icons-data-devicon nerd-icons-data-sucicon nerd-icons-data-wicon
>> nerd-icons-data-faicon nerd-icons-data-powerline nerd-icons-data-octicon
>> nerd-icons-data-pomicon nerd-icons-data-ipsicon disable-mouse mingus
>> libmpdee evil-collection-mpdel mpdel mpdel-browser libmpdel-directory
>> mpdel-playlist mpdel-tablist mpdel-song mpdel-core navigel
>> evil-collection-bookmark bookmark evil-collection-tablist tablist
>> tablist-filter semantic/wisent/comp semantic/wisent
>> semantic/wisent/wisent semantic/util-modes semantic/util semantic
>> semantic/tag semantic/lex semantic/fw mode-local find-func cedet
>> libmpdel tq time-stamp posframe esup esup-child benchmark
>> ssh-config-mode jq-mode json-mode json-snatcher js c-ts-common treesit
>> cc-mode cc-fonts cc-guess cc-menus cc-cmds cc-styles cc-align cc-engine
>> cc-vars cc-defs evil-collection-yaml-mode yaml-mode toml-mode conf-mode
>> align highlight facemenu nix-mode ffap smie nix-repl nix-shell nix-store
>> evil-collection-magit-section magit-section cursor-sensor llama nix-log
>> nix-instantiate nix-shebang nix-format nix sudo-edit tramp trampver
>> tramp-integration tramp-message tramp-compat shell pcomplete parse-time
>> iso8601 time-date tramp-loaddefs evil-collection-devdocs devdocs mathjax
>> evil-terminal-cursor-changer evil-visualstar evil-commentary
>> evil-commentary-integration evil-collection-evil-mc evil-mc
>> evil-mc-command-execute evil-mc-command-record evil-mc-cursor-make
>> evil-mc-region evil-mc-cursor-state evil-mc-undo evil-mc-vars
>> evil-mc-known-commands evil-mc-common evil-exchange evil-lion evil-args
>> smartscan timeout ess ess-utils ess-custom evil-collection-unimpaired
>> evil-collection-vc-git evil-collection-tabulated-list
>> evil-collection-tab-bar evil-collection-simple evil-collection-replace
>> evil-collection-process-menu evil-collection-package-menu
>> evil-collection-minibuffer evil-collection-man evil-collection-kmacro
>> evil-collection-indent evil-collection-imenu evil-collection-help
>> evil-collection-flymake evil-collection-elisp-mode evil-collection-eldoc
>> evil-collection-elpaca evil-collection-dired evil-collection-diff-mode
>> evil-collection-custom evil-collection-compile evil-collection-comint
>> evil-collection-calendar evil-collection-buff-menu evil-collection
>> annalist sqlite3 sqlite3-api treebundel vc-git diff-mode track-changes
>> files-x git-link dired dired-loaddefs texfrag face-remap shr pixel-fill
>> kinsoku url-file puny svg dom preview latex latex-flymake flymake
>> project compile text-property-search comint ansi-osc tex-ispell
>> tex-style tex dbus xml crm texmathp auctex display-line-numbers
>> elec-pair lisp-mnt package browse-url xdg url-handlers xterm-color
>> edit-list-autoloads refine-autoloads list-utils-autoloads loop-autoloads
>> prompts-autoloads file-info-autoloads hydra-autoloads lv-autoloads
>> browse-at-remote-autoloads image-roll-autoloads
>> saveplace-pdf-view-autoloads pdfgrep-autoloads toc-mode-autoloads
>> scratch-autoloads persistent-scratch-autoloads exercism-autoloads
>> a-autoloads request-autoloads async-autoloads async-await-autoloads
>> promise-autoloads iter2-autoloads persist-autoloads
>> indent-bars-autoloads rainbow-delimiters-autoloads
>> rainbow-mode-autoloads mode-line-bell-autoloads powerthesaurus-autoloads
>> hydra lv jeison-autoloads ripgrep-autoloads wgrep-autoloads
>> vlf-autoloads gptai-autoloads popper-autoloads ctrlf-autoloads
>> nerd-icons-dired-autoloads nerd-icons-completion-autoloads
>> nerd-icons-autoloads disable-mouse-autoloads mingus-autoloads
>> libmpdee-autoloads mpdel-autoloads libmpdel-autoloads navigel-autoloads
>> tablist-autoloads posframe-autoloads esup-autoloads quickrun-autoloads
>> ht-autoloads ssh-config-mode-autoloads jq-mode-autoloads
>> json-mode-autoloads json-snatcher-autoloads yaml-mode-autoloads
>> toml-mode-autoloads highlight-escape-sequences-autoloads
>> highlight-autoloads highlight-numbers-autoloads parent-mode-autoloads
>> nix-mode-autoloads magit-section-autoloads llama-autoloads
>> sudo-edit-autoloads attrap-autoloads f-autoloads dash-autoloads
>> s-autoloads devdocs-autoloads mathjax-autoloads
>> evil-terminal-cursor-changer-autoloads evil-surround-autoloads
>> evil-visualstar-autoloads evil-commentary-autoloads evil-mc-autoloads
>> evil-exchange-autoloads evil-lion-autoloads evil-args-autoloads
>> smartscan-autoloads timeout-autoloads ess-autoloads
>> info-colors-autoloads evil-collection-autoloads annalist-autoloads
>> sqlite3-autoloads treebundel-autoloads git-link-autoloads
>> texfrag-autoloads auctex-autoloads tex-site xterm-color-autoloads ispell
>> which-func imenu man ansi-color autorevert filenotify cal-menu calendar
>> cal-loaddefs advice evil evil-integration evil-maps evil-commands reveal
>> evil-jumps evil-command-window evil-types evil-search evil-ex
>> evil-macros evil-repeat evil-states evil-core comp comp-cstr warnings
>> comp-run comp-common rx evil-common thingatpt rect evil-vars ring
>> undo-fu goto-chg evil-autoloads undo-fu-autoloads goto-chg-autoloads
>> transient pcase format-spec transient-autoloads general memoize
>> sanityinc-tomorrow-bright-theme color-theme-sanityinc-tomorrow color
>> minions compat general-autoloads memoize-autoloads
>> color-theme-sanityinc-tomorrow-autoloads minions-autoloads
>> el-patch-autoloads el-patch el-patch-stub edmacro kmacro vc
>> vc-dispatcher cl-extra help-mode elpaca-use-package use-package
>> use-package-ensure use-package-delight use-package-diminish
>> use-package-bind-key bind-key easy-mmode use-package-core
>> elpaca-use-package-autoloads elpaca-log elpaca-ui elpaca-menu-elpa
>> elpaca-menu-melpa url url-proxy url-privacy url-expand url-methods
>> url-history url-cookie generate-lisp-file url-domsuf url-util url-parse
>> auth-source cl-seq eieio eieio-core cl-macs password-cache json subr-x
>> map byte-opt gv bytecomp byte-compile url-vars mailcap elpaca-menu-org
>> elpaca elpaca-process elpaca-autoloads early-init cus-edit pp cus-load
>> icons wid-edit cl-loaddefs cl-lib rmc iso-transl tooltip cconv eldoc
>> paren electric uniquify ediff-hook vc-hooks lisp-float-type elisp-mode
>> mwheel term/pgtk-win pgtk-win term/common-win touch-screen pgtk-dnd
>> tool-bar dnd fontset image regexp-opt fringe tabulated-list replace
>> newcomment text-mode lisp-mode prog-mode register page tab-bar menu-bar
>> rfn-eshadow isearch easymenu timer select scroll-bar mouse jit-lock
>> font-lock syntax font-core term/tty-colors frame minibuffer nadvice seq
>> simple cl-generic indonesian philippine cham georgian utf-8-lang
>> misc-lang vietnamese tibetan thai tai-viet lao korean japanese eucjp-ms
>> cp51932 hebrew greek romanian slovak czech european ethiopic indian
>> cyrillic chinese composite emoji-zwj charscript charprop case-table
>> epa-hook jka-cmpr-hook help abbrev obarray oclosure cl-preloaded button
>> loaddefs theme-loaddefs faces cus-face macroexp files window
>> text-properties overlay sha1 md5 base64 format env code-pages mule
>> custom widget keymap hashtable-print-readable backquote threads dbusbind
>> inotify dynamic-setting system-font-setting font-render-setting cairo
>> gtk pgtk lcms2 multi-tty move-toolbar make-network-process
>> tty-child-frames native-compile mps emacs)
>>
>> Memory information:
>> ((conses 24 0 0) (symbols 56 0 0) (strings 40 0 0) (string-bytes 1 0)
>>    (vectors 24 0) (vector-slots 8 0 0) (floats 24 0 0) (intervals 64 0 0)
>>    (buffers 1000 0))
>