Subject: 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: Sat, 19 Apr 2025 13:10:57 +0800

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_igc-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-7b35a5062231ec5a11c7a87d4797cfb5dba25121-O3/share/emacs/31.0.50/lisp/theme-loaddefs
/home/exec/.emacs.d/elpaca/builds/transient/transient hides /home/exec/Projects/git.savannah.gnu.org/git/emacs-build/feature_igc-7b35a5062231ec5a11c7a87d4797cfb5dba25121-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))

--