Subject: 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: Mon, 21 Apr 2025 23:21:23 +0200

Yes, I did exactly the same steps.
I lost all the colors in level 4 only because all the text is colored with the 
`font-lock-waning-face' (see the attached screenshot). This is because tree-
sitter-rust indicates several nodes as ERROR, as shown in the tree-sitter-
explorer window. rust-ts-mode has a rule that should color the nodes indicated 
with ERROR with `font-lock-warning-face', however it colors the whole buffer.
If I look at a less complex example the colors are all there.
I can try and write a tighter rule that doesn't color the whole buffer with 
font-lock-warning-face'.

Vincenzo

p.s. for Eli and Jury: I'm using libtreesitter-0.25.2 and tree-sitter-rust 
v0.24.0 (Fedora 42)

In data domenica 20 aprile 2025 09:19:20 Ora legale dell’Europa centrale, Eval 
Exec ha scritto:
> Oh! In the reproduce step, I write a typo, the bug can be reproduced by
> setting different `treesit-font-lock-level`, wen
> `treesit-font-lock-level` is 3, all colors are good, when
> treesit-font-lock-level is 4, all colors are lost.
> To reproduce this: use this rust file:
> 
> Then eval:
> 1. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> all color are lost.
> 
> 2. (progn  (setq treesit-font-lock-level 3) (revert-buffer))
> colors are good. !Important, level 3 is good, but level 4 lost colors.
> 
> 3. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> all color are lost again.
> 
> 
> Can you reproduce this?
> 
> On 4/20/25 06:12, Vincenzo Pupillo wrote:
> > If the attached file is correct, it appears to be a grammar bug (the tree-
> > sitter-rust grammar). Take a look at the attached screenshot (libtree-
> > sitter-0.25.2 and tree-sitter-rust v0.24.0)
> > 
> > Vincenzo
> > 
> > In data sabato 19 aprile 2025 07:10:57 Ora legale dell’Europa centrale,
> > Eval> 
> > Exec ha scritto:
> >> Hello,
> >> I'm visiting a rust file, when I set treesit-font-lock-level to 3, all
> >> color are good, when I set treesit-font-lock-level to 4, all color as
> >> lost.
> >> To reproduce this: use this rust file:
> >> 
> >> Then eval:
> >> 1. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> >> all color are lost.
> >> 
> >> 2. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> >> colors are good.
> >> 
> >> 3. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> >> all color are lost again.
> >> 
> >> 
> >> ```rust
> >> 
> >> //! Primitive traits and types representing basic properties of types.
> >> //!
> >> //! Rust types can be classified in various useful ways according to
> >> //! their intrinsic properties. These classifications are represented
> >> //! as traits.
> >> 
> >> #![stable(feature = "rust1", since = "1.0.0")]
> >> 
> >> use crate::cell::UnsafeCell;
> >> use crate::cmp;
> >> use crate::fmt::Debug;
> >> use crate::hash::{Hash, Hasher};
> >> 
> >> /// Implements a given marker trait for multiple types at the same time.
> >> ///
> >> /// The basic syntax looks like this:
> >> /// ```ignore private macro
> >> /// marker_impls! { MarkerTrait for u8, i8 }
> >> /// ```
> >> /// You can also implement `unsafe` traits
> >> /// ```ignore private macro
> >> /// marker_impls! { unsafe MarkerTrait for u8, i8 }
> >> /// ```
> >> /// Add attributes to all impls:
> >> /// ```ignore private macro
> >> /// marker_impls! {
> >> ///     #[allow(lint)]
> >> ///     #[unstable(feature = "marker_trait", issue = "none")]
> >> ///     MarkerTrait for u8, i8
> >> /// }
> >> /// ```
> >> /// And use generics:
> >> /// ```ignore private macro
> >> /// marker_impls! {
> >> ///     MarkerTrait for
> >> ///         u8, i8,
> >> ///         {T: ?Sized} *const T,
> >> ///         {T: ?Sized} *mut T,
> >> ///         {T: MarkerTrait} PhantomData<T>,
> >> ///         u32,
> >> /// }
> >> /// ```
> >> #[unstable(feature = "internal_impls_macro", issue = "none")]
> >> // Allow implementations of `UnsizedConstParamTy` even though std cannot
> >> use that feature. #[allow_internal_unstable(unsized_const_params)]
> >> macro marker_impls {
> >> 
> >>      ( $(#[$($meta:tt)*])* $Trait:ident for $({$($bounds:tt)*})? $T:ty
> >>      $(,
> >> 
> >> $($rest:tt)*)? ) => { $(#[$($meta)*])* impl< $($($bounds)*)? > $Trait for
> >> $T {}
> >> 
> >>          marker_impls! { $(#[$($meta)*])* $Trait for $($($rest)*)? }
> >>      
> >>      },
> >>      ( $(#[$($meta:tt)*])* $Trait:ident for ) => {},
> >>      
> >>      ( $(#[$($meta:tt)*])* unsafe $Trait:ident for $({$($bounds:tt)*})?
> >>      $T:ty
> >> 
> >> $(, $($rest:tt)*)? ) => { $(#[$($meta)*])* unsafe impl< $($($bounds)*)? >
> >> $Trait for $T {} marker_impls! { $(#[$($meta)*])* unsafe $Trait for
> >> $($($rest)*)? } },
> >> 
> >>      ( $(#[$($meta:tt)*])* unsafe $Trait:ident for ) => {},
> >> 
> >> }
> >> 
> >> /// Types that can be transferred across thread boundaries.
> >> ///
> >> /// This trait is automatically implemented when the compiler determines
> >> it's /// appropriate.
> >> ///
> >> /// An example of a non-`Send` type is the reference-counting pointer
> >> /// [`rc::Rc`][`Rc`]. If two threads attempt to clone [`Rc`]s that point
> >> to
> >> the same /// reference-counted value, they might try to update the
> >> reference count at the /// same time, which is [undefined behavior][ub]
> >> because [`Rc`] doesn't use atomic /// operations. Its cousin
> >> [`sync::Arc`][arc] does use atomic operations (incurring /// some
> >> overhead)
> >> and thus is `Send`.
> >> ///
> >> /// See [the Nomicon](../../nomicon/send-and-sync.html) and the [`Sync`]
> >> trait for more details. ///
> >> /// [`Rc`]: ../../std/rc/struct.Rc.html
> >> /// [arc]: ../../std/sync/struct.Arc.html
> >> /// [ub]: ../../reference/behavior-considered-undefined.html
> >> #[stable(feature = "rust1", since = "1.0.0")]
> >> #[cfg_attr(not(test), rustc_diagnostic_item = "Send")]
> >> #[diagnostic::on_unimplemented(
> >> 
> >>      message = "`{Self}` cannot be sent between threads safely",
> >>      label = "`{Self}` cannot be sent between threads safely"
> >> 
> >> )]
> >> pub unsafe auto trait Send {
> >> 
> >>      // empty.
> >> 
> >> }
> >> 
> >> #[stable(feature = "rust1", since = "1.0.0")]
> >> impl<T: ?Sized> !Send for *const T {}
> >> #[stable(feature = "rust1", since = "1.0.0")]
> >> impl<T: ?Sized> !Send for *mut T {}
> >> 
> >> // Most instances arise automatically, but this instance is needed to
> >> link
> >> up `T: Sync` with // `&T: Send` (and it also removes the unsound default
> >> instance `T Send` -> `&T: Send` that would // otherwise exist).
> >> #[stable(feature = "rust1", since = "1.0.0")]
> >> unsafe impl<T: Sync + ?Sized> Send for &T {}
> >> 
> >> /// Types with a constant size known at compile time.
> >> ///
> >> /// All type parameters have an implicit bound of `Sized`. The special
> >> syntax /// `?Sized` can be used to remove this bound if it's not
> >> appropriate. ///
> >> /// ```
> >> /// # #![allow(dead_code)]
> >> /// struct Foo<T>(T);
> >> /// struct Bar<T: ?Sized>(T);
> >> ///
> >> /// // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for
> >> [i32] /// struct BarUse(Bar<[i32]>); // OK
> >> /// ```
> >> ///
> >> /// The one exception is the implicit `Self` type of a trait. A trait
> >> does
> >> not /// have an implicit `Sized` bound as this is incompatible with
> >> [trait
> >> object]s /// where, by definition, the trait needs to work with all
> >> possible implementors, /// and thus could be any size.
> >> ///
> >> /// Although Rust will let you bind `Sized` to a trait, you won't
> >> /// be able to use it to form a trait object later:
> >> ///
> >> /// ```
> >> /// # #![allow(unused_variables)]
> >> /// trait Foo { }
> >> /// trait Bar: Sized { }
> >> ///
> >> /// struct Impl;
> >> /// impl Foo for Impl { }
> >> /// impl Bar for Impl { }
> >> ///
> >> /// let x: &dyn Foo = &Impl;    // OK
> >> /// // let y: &dyn Bar = &Impl; // error: the trait `Bar` cannot
> >> ///                             // be made into an object
> >> /// ```
> >> ///
> >> /// [trait object]: ../../book/ch17-02-trait-objects.html
> >> #[doc(alias = "?", alias = "?Sized")]
> >> #[stable(feature = "rust1", since = "1.0.0")]
> >> #[lang = "sized"]
> >> #[diagnostic::on_unimplemented(
> >> 
> >>      message = "the size for values of type `{Self}` cannot be known at
> >> 
> >> compilation time", label = "doesn't have a size known at compile-time"
> >> )]
> >> #[fundamental] // for Default, for example, which requires that `[T]:
> >> !Default` be evaluatable #[rustc_specialization_trait]
> >> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =
> >> false))] #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
> >> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
> >> #[rustc_coinductive]
> >> pub trait Sized {
> >> 
> >>      // Empty.
> >> 
> >> }
> >> 
> >> /// Types that can be "unsized" to a dynamically-sized type.
> >> ///
> >> /// For example, the sized array type `[i8; 2]` implements `Unsize<[i8]>`
> >> and /// `Unsize<dyn fmt::Debug>`.
> >> ///
> >> /// All implementations of `Unsize` are provided automatically by the
> >> compiler. /// Those implementations are:
> >> ///
> >> /// - Arrays `[T; N]` implement `Unsize<[T]>`.
> >> /// - A type implements `Unsize<dyn Trait + 'a>` if all of these
> >> conditions
> >> are met: ///   - The type implements `Trait`.
> >> ///   - `Trait` is dyn-compatible[^1].
> >> ///   - The type is sized.
> >> ///   - The type outlives `'a`.
> >> /// - Structs `Foo<..., T1, ..., Tn, ...>` implement `Unsize<Foo<..., U1,
> >> ..., Un, ...>>` /// where any number of (type and const) parameters may
> >> be
> >> changed if all of these conditions /// are met:
> >> ///   - Only the last field of `Foo` has a type involving the parameters
> >> `T1`, ..., `Tn`. ///   - All other parameters of the struct are equal.
> >> ///   - `Field<T1, ..., Tn>: Unsize<Field<U1, ..., Un>>`, where
> >> `Field<...>` stands for the actual ///     type of the struct's last
> >> field.
> >> ///
> >> /// `Unsize` is used along with [`ops::CoerceUnsized`] to allow
> >> /// "user-defined" containers such as [`Rc`] to contain dynamically-sized
> >> /// types. See the [DST coercion RFC][RFC982] and [the nomicon entry on
> >> coercion][nomicon-coerce] /// for more details.
> >> ///
> >> /// [`ops::CoerceUnsized`]: crate::ops::CoerceUnsized
> >> /// [`Rc`]: ../../std/rc/struct.Rc.html
> >> /// [RFC982]:
> >> https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
> >> ///
> >> [nomicon-coerce]: ../../nomicon/coercions.html
> >> /// [^1]: Formerly known as *object safe*.
> >> #[unstable(feature = "unsize", issue = "18598")]
> >> #[lang = "unsize"]
> >> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =
> >> false))] #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
> >> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
> >> pub trait Unsize<T: ?Sized> {
> >> 
> >>      // Empty.
> >> 
> >> }
> >> 
> >> /// Required trait for constants used in pattern matches.
> >> ///
> >> /// Any type that derives `PartialEq` automatically implements this
> >> trait,
> >> /// *regardless* of whether its type-parameters implement `PartialEq`.
> >> ///
> >> /// If a `const` item contains some type that does not implement this
> >> trait, /// then that type either (1.) does not implement `PartialEq`
> >> (which means the /// constant will not provide that comparison method,
> >> which code generation /// assumes is available), or (2.) it implements
> >> *its own* version of /// `PartialEq` (which we assume does not conform
> >> to a
> >> structural-equality /// comparison).
> >> ///
> >> /// In either of the two scenarios above, we reject usage of such a
> >> constant in /// a pattern match.
> >> ///
> >> /// See also the [structural match RFC][RFC1445], and [issue 63438] which
> >> /// motivated migrating from an attribute-based design to this trait.
> >> ///
> >> /// [RFC1445]:
> >> https://github.com/rust-lang/rfcs/blob/master/text/1445-restrict-constant
> >> s-> 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-extern
> >> al
> >> -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/featu
> >>   re_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-7b35
> >> a5
> >> 062231ec5a11c7a87d4797cfb5dba25121-O3/share/emacs/31.0.50/lisp/theme-load
> >> def s /home/exec/.emacs.d/elpaca/builds/transient/transient hides
> >> /home/exec/Projects/git.savannah.gnu.org/git/emacs-build/feature_igc-7b35
> >> a5
> >> 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))