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

From: Vincenzo Pupillo <[email-masked]>
Date: Sun, 20 Apr 2025 00:12:34 +0200

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))